Java：单例模式的七种写法

转载出处 : http://www.blogjava.net/kenzhh/archive/2013/03/15/357824.html

谏言:

简单来说，第一种第二种不要考虑，第三种第四种其实一样，平常面试推荐第三四五七，考虑到线程安全直接使用第七种。

第一种:（懒汉，线程不安全）

public class Singleton1 {
	private static Singleton1 instance ;
	private Singleton1(){};
	public static Singleton1 getInstance(){
		if(instance==null){
			instance = new Singleton1();
			};
			return instance;
		}
		
	}

这种写法lazy loading很明显，但是致命的是在多线程不能正常工作。

第二种:（懒汉，线程安全）

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

这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，遗憾的是，效率很低，99%情况下不需要同步。

第三种:（饿汉式）

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

这种方式基于 classloder 机制避免了多线程的同步问题，不过， instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法，   但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

第四种:(饿汉，变种)

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

表面上看起来差别挺大，其实更第三种方式差不多，都是在类初始化即实例化instance。

第五种:(静态内部类)

public class Singleton5 {
	private Singleton5(){};
	
	private static class SingletonHolder{
		private static final Singleton5 INSTANCE = new Singleton5();
	};
	
	public static final Singleton5 getInstance(){
		return SingletonHolder.INSTANCE;
	}
}

这种方式同样利用了 classloder 的机制来保证初始化 instance 时只有一个线程，它跟第三种和第四种方式不同的是（很细微的差别）：第三种和第四种方式是只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了， instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有显示通过调用 getInstance 方法时，才会显示装载 SingletonHolder 类，从而实例化 instance 。想象一下，如果实例化 instance 很消耗资源，我想让他延迟加载，另外一方面，我不希望在 Singleton 类加载时就实例化，因为我不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第三和第四种方式就显得很合理。

第六种:(枚举)

1public enum Singleton {  
2     INSTANCE;  
3     public void whateverMethod() {  
4     }  
5 }  

这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过，个人认为由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏，在实际工作中，我也很少看见有人这么写过。

第七种:(双重校验锁)

public class Singleton6 {
	private volatile static Singleton6 instance;
	
	private Singleton6(){};
	
	public static Singleton6 getInstance(){
		if(instance==null){
			synchronized(Singleton6.class){
				if(instance==null){
					instance = new Singleton6();
				}
			}
		}
		return instance;
	}
	
}

在JDK1.5之后，双重检查锁定才能够正常达到单例效果。