单例模式

概念

  顾名思义，就是无论如何，只让生成一个实例对象的模式了。本篇主要介绍几种单例模式的写法。

懒汉式，线程不安全

  最基本的实现，但最大的问题就是不支持多线程。

public class LazeM {
	private static LazeM lazem;
	
	private LazeM(){}
	
	public static LazeM getInstance(){
		if(lazem==null){
			lazem = new LazeM();
		}
		return lazem;
	}
}

懒汉式，线程安全

  这种模式，相较于前一种，添加了synchronized关键字。支持多线程，但是效率比较低。

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

饿汉式、线程安全

  这种模式，多线程时安全的，但是很明显，不是懒加载。

public class Lazy {
	private static Lazy lazyInstance = new Lazy();
	
	private Lazy(){};
	
	public static Lazy getInstance(){
		return lazyInstance;
	}
}

双重检查锁（dcl）

  这种模式，效率高，支持多线程，而且好多面试java的时候愿意问这个。

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

静态内部类

  这种方式能达到双检锁方式一样的功效，但实现更简单。

public class StaticM {
	private static class StaticMHolder{
		private static final StaticM staticM = new StaticM(); 
	}
	
	private StaticM(){}
	
	public static final StaticM getInstanc(){
		return StaticMHolder.staticM;
	}
}

枚举

  这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

The End

  所有的单例模式都需要把构造函数设置位private。一般情况下，建议使用饿汉式单例，如果明确需要懒加载的话，可以使用静态内部类的方式。当然，dcl也是很好用的。