Java实现单例模式（各种方法的优缺点）

单例模式算是设计模式中最容易理解，不少面试过程中都要求手写单例模式

单例模式多种：懒汉式、饿汉式、静态内部类、枚举

---

饿汉式：

这种方法非常简单，因为单例的实例被声明成 static 和 final 变量了，在第一次加载类到内存中时就会初始化，所以创建实例本身是线程安全的。

public class Singleton{
//类加载时就初始化
	private static final Singleton instance = new Singleton();

	private Singleton(){}

	public static Singleton getInstance(){
    	return instance;
	}
}

但是这种单例模式有一定的局限性：

1、单例的实例一开始就被初始化了，及时在整个程序中没有用到getInstance( )，实例还是存在在内存中

2、当单例实例的初始化依靠程序中其他的参数时，就不能用这种单例模式了

---

懒汉式

public class Singleton{//（正确但低效的版本）

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

这种方法由于我们把getInstance( )声明为同步方法，所以做到了线程安全，并且解决了多实例的问题，但是它并不高效。

想象一下每个线程调用getInstance( )方法时都要判断一次instance是否是空。然而同步操作只需要在第一次调用时才被需要，即第一次创建单例实例对象时，之后所有的调用直接返回instance即可

所以就有以下的代码，一般吧这种方法称为双重检验锁模式（double checked locking pattern）

即进行两次 instance == null？ 的判断，如果为true才能进入同步代码块，而在同步代码块中再检测一次是因为可能会有多个线程一起进入同步块外的 if，如果在同步块内不进行二次检验的话就有可能会生成多个实例了。

public class Singleton{//（有问题的版本）

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

然而上面的代码还是有问题的，主要在于instance = new Singleton()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。

给 instance 分配内存
调用 Singleton 的构造函数来初始化成员变量
将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，此时另外有一个线程进行第一个判断，发现instance！=null，返回instance（但其实instance还没有完成初始化），使用会导致报错，当然发生错误的概率极低，但是这个错误我们是可以规避的

只需要将 instance 变量声明成 volatile 就可以了。

public class Singleton{//（正确且高效的版本）

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

使用 volatile 的主要原因是其另一个特性：禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。比如上面的例子，取操作必须在执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作（这里的“后面”是时间上的先后顺序）。

但是特别注意

在 Java 5 以前的版本使用了 volatile 的双检锁还是有问题的。其原因是 Java 5 以前的 JMM （Java 内存模型）是存在缺陷的，即时将变量声明成 volatile 也不能完全避免重排序，主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复，所以在这之后才可以放心使用 volatile。

---

静态内部类方式

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

这种写法仍然使用JVM本身机制保证了线程安全问题；由于 SingletonHolder 是私有的，除了 getInstance() 之外没有办法访问它，因此它是懒汉式的；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本。

---

枚举方式

用枚举写单例实在太简单了！这也是它最大的优点。下面这段代码就是声明枚举实例的通常做法。

public enum EasySingleton{
    INSTANCE;
    //变量
    //方法
}

我们可以通过EasySingleton.INSTANCE来访问实例，这比调用getInstance()方法简单多了。创建枚举默认就是线程安全的，所以不需要担心double checked locking，而且还能防止反序列化导致重新创建新的对象。在《Effective Java》中说枚举是实现单例的最佳方式.建议在实际项目中单例以枚举方式实现.

---

总结:

一般情况下直接使用饿汉式就好了，如果明确要求要懒加载（lazy initialization）会倾向于使用静态内部类，如果涉及到反序列化创建对象时会试着使用枚举的方式来实现单例。