单例模式/singleton模式/创建型模式

Java实现要点:

  • 私有构造方法
  • 线程安全(并发的考虑)
  • 延迟加载(效率的考虑,对于较大的类在使用时在加载)
  • 公有方法访问单一实例

常见单例模式代码及问题

//无延迟加载,常驻内存(即使不使用)
class Singleton {
    private final static Singleton INSTANCE = new Singleton();
	private Singleton() {
	}
	public static Singleton getInstance() {
		return INSTANCE;
	}
}

//无延迟加载,常驻内存(即使不使用)
public class Singleton {
    private static Singleton instance;
    static {
        instance = new Singleton();
    }
    private Singleton() {}
    public Singleton getInstance() {
        return instance;
    }
}

//非线程安全
public class Singleton {
    private static Singleton singleton;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

//同步粒度大,初始化后效率低
public class Singleton {
    private static Singleton singleton;
    private Singleton() {}
    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

//非线程安全
public class Singleton {
    private static Singleton singleton;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
        //多线程可以同时到这
            synchronized (Singleton.class) {
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}


推荐单例模式代码示例:

//双重检测,线程安全,延迟加载,效率较好
public class Singleton {
    private static volatile Singleton singleton;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

//降低同步粒度,线程安全,延迟加载,效率较好
public class Singleton4 {
    private static Singleton4 instance=null;
	private Singleton4 () {
	}
	private static synchronized  void synUnit() {
		if (instance==null) {
			instance=new Singleton4();			
		}
	}
	public static  Singleton4 getInstance() {
		if (instance==null) {
			synUnit();
		}
		return instance;
	}
}

    /*
	 * 使用内部类来维护单例的实现,JVM内部的机制能够保证当一个类被加载的时候,这个类的加载过程是线程互斥的。
	 * 这样当我们第一次调用getInstance的时候,JVM能够帮我们保证instance只被创建一次,并且会保证把赋值给instance的内存初始化完毕,
	 * 这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制,这样就解决了低性能问题。
	 * 
	 * */
public class Singleton {
    private Singleton() {}
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

//单枚举类型,实现单例,无偿提供序列化,Effective Java推荐的方式。
public enum Singleton {
    INSTANCE;
	public void method() {
		System.out.println("hello world");
	}
}


总结

  • synchronized关键字锁定的是对象,在用的时候,一定要在恰当的地方使用(注意需要使用锁的对象和过程,可能有的时候并不是整个对象及整个过程都需要锁)。

静态类

  • 静态类不能实现接口。(从类的角度说是可以的,但是那样就破坏了静态了。因为接口中不允许有static修饰的方法,所以即使实现了也是非静态的)。
  • 单例可以被延迟初始化,静态类一般在第一次加载是初始化。之所以延迟加载,是因为有些类比较庞大,所以延迟加载有助于提升性能。
  • 单例类可以被继承,他的方法可以被覆写。但是静态类内部方法都是static,无法被覆写。

参考这里

posted @ 2015-09-24 18:54  toto怎么会喝醉  阅读(466)  评论(0编辑  收藏  举报