单例模式

 

前段时间在iteye上关于单例模式讨论很火热，单例也是自己在工作中用得最多的设计模式，写此博文总结一下自己对单例的理解，方便以后查看。

单例模式常用的有五种实现，在类加载的时候把单例初始化了，使用getInstance方法是只是简单的return单例的实例，这种实现方式就叫做饿汉式。饿汉式的优点是线程安全的，缺点是不能延时加载。

饿汉式单例实现代码(代码1)

 

public class Singleton{
	
	private static Singleton instance = new Singleton();
	
	private Singleton(){ }
	
	private static Singleton getInstance(){
		return instance;
	}
}

 

       如果单例类的初始化开销很大，用户希望在使用的时候创建单例类，在调用getInstance的时候才去判断单例是否初始化，如果没有就初始化，然后return单例实例，这种延迟初始化来提高程序启动速度的，叫做饱汉式。饱汉式实现了延时加载，但是在多线程环境下，如果不同步getInstance方法会有线程安全问题，如果同步getInsatance方法就会变成串行执行，执行效率会变低。

线程安全的饱汉式（代码2）

 

public class Singleton {
	
	private static Singleton instance;
	
	private Singleton(){ }
	
	public static synchronized Singleton getInstance(){
		if(instance==null){
			instance = new Singleton();//1
		}
		return instance;
	}
}

 

      上述代码中的getInstance方法在多线程环境下运行的很好，然而，当分析这段代码时，您会意识到只有在第一次调用方法时才需要同步。由于只有第一次调用执行了 //1 处的代码，而只有此行代码需要同步，因此就无需对后续调用使用同步。所有其他调用仅判断 instance 是非 null 的，并将其返回。多线程能够安全并发地执行除第一次调用外的所有调用。尽管如此，由于该方法是synchronized 的，需要为该方法的每一次调用付出同步的代价，即使只有第一次调用需要同步。因此，为了是getInstance方法更为高效，出现了下面这种实现代码（代码3）

 

public class Singleton{
	
	private static Singleton instance;
	
	private Singleton(){ }
	
	public static Singleton getInstance(){
		if(instance==null){                                    //1
			synchronized (Singleton.class) {       //2
			       instance = new Singleton();       //3
			}
		}
		return instance;
	}
}

   

     代码 3中的代码展示了用多线程加以说明。当instance为null时，两个线程可以并发地进入if语句内部。然后，一个线程进入synchronized块来初始化instance，而另一个线程则被阻断。当第一个线程退出synchronized块时，等待着的线程进入并创建另一个Singleton对象。注意：当第二个线程进入synchronized块时，它并没有检查instance是否非null。为了解决代码3中的问题，我们需要对instance进行二次检查，这就是双重检查锁定实现。

（代码4）

 

public class Singleton{
	
	private static Singleton instance;
	
	private Singleton(){ }
	
	public static Singleton getInstance(){
		if(instance==null){                        
			synchronized (Singleton.class) {       //1
				if(instance==null){                //2
					instance = new Singleton();    //3
				}
			}
		}
		return instance;
	}
}

  

     双重检查锁定背后的理论是：在//2处二次检查instance，使得创建两个instance成为不可能。双重检查锁定背后的理论是完美的，不幸的是，现实完全不同。双重检查锁定的问题是：java平台内存模型并不能保证它会顺利运行。

（深究这个问题请参考：http://www.ibm.com/developerworks/cn/java/j-dcl.html）

    在貌似只有饿汉式的实现才能解决问题之际，一种全新的思想被提了出来，那就是静态内部类实现，代码如下：

 

public class Singleton{
	
	private Singleton(){}
	
	//静态内部类
	static class innerSingleton{
		static Singleton instance = new Singleton();
	}
	
	public static Singleton getInstance(){
		return innerSingleton.instance;
	}
}

 

     使用静态内部类，jvm在加载Singleton是并不加载它的内部类innerSingleton，而是在调用getInstance方法时调用innerSingleton才加载innweSingleton,从而调用Singleton的构造方法，实例化Singleton，从而在不需要同步的情况下实现了延时初始化的效果，推荐使用该种单例实现。

 

   最后一种就是使用枚举实现，枚举的优点是不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。但是失去了类的一些特性，没有延迟加载，用的人也太少了，实现代码如下：

 

public enum Singleton {
	instance;
	public void singletonOpr1(){
		System.out.println("singletonOpr1 run");
	}
	public void singletonOpr2(){
		System.out.println("singletonOpr2 run");
	}
}