一个类只有一个实例，自行实例化并提供给整个系统。
将该类构造函数私有化，并通过静态方法获取一个唯一实例，获取过程保证线程安全。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) { //分水岭
instance = new Singleton();
}
return instance;
}
}
假设有A、B线程同时调用getInstance方法，在分水岭同时执行完判断后，由于CPU时间片切换，假设A线程得到执行权，继续向下执行，实例化了对象，此时instance不为空，而B线程又做了实例化工作，就会导致实例不唯一。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
在getInstance()方法前加上synchronized，使整个方法同步，就可以保证线程安全，避免多实例的问题，但是这样并不高效，因为在第一次调用过getInstance()方法后，instance不为空，之后再调用该方法都要走同步，这样会消耗不必要的资源。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getSingleton() {
if (instance == null) { //Single Checked
synchronized (Singleton.class) {
if (instance == null) { //Double Checked
instance = new Singleton();
}
}
}
return instance ;
}
}
这里为啥要做两次检验呢？我们先来看下，如果去掉第一层检验会怎样
public static Singleton getSingleton() {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
return instance ;
}
当有两个线程同时调用getSingleton()方法时，由于同步机制的存在，假设此时A线程得到CPU的执行权，走到同步块中执行，执行了instance = new Singleton()后，退出同步语句块，此时instance已经不为null了，这时候B线程获得CPU执行权也进入同步块，就会被instance == null的判断挡在外面了。
所以就算不要第一层检验也是可以实现多线程安全的单例，那为毛还要写？原来这里涉及到性能问题，上面懒汉式线程安全的写法也是安全的，但是每次调用都要走同步会影响性能，这里也一样。我们希望这里的new Singleton()只执行一次，如果少了第一层的判断，每次有线程进入 getInstance()时，均会执行锁定操作来实现线程同步，这是非常耗费性能的，而多了第一层检验，只有第一次instance == null会执行锁定操作，之后的调用直接return instance就行。
再看如果少了第二层检验，其实这就跟第一种懒汉式线程不安全写法一样，在多线程并发的情况下不能达到保持单例的效果。
那么双重检验机制是否就能完美解决问题？其实不然，其原因在于instance = new Singleton();这句并非是个原子操作，当JVM运行到这一句是，分别作了如下操作
1.在堆中为 instance 分配内存
2.调用 Singleton的构造函数初始化成员变量
3.将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）
如果上面的操作按1-2-3顺序执行，那就没啥问题，但是由于JVM的即时编译器中存在指令重排序的优化，上面的操作有可能是1-3-2。这会出现啥情况？
public static Singleton getSingleton() {
if (instance == null) { //p2
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton(); //p1
}
}
}
return instance ;
}
假设线程A此时走到p1处，JVM按照1-3-2的顺序实例化instance,才执行完1-3，来不及执行2，线程B获得了CPU执行权也调用了getInstance()方法，并走到p2处，此时instance不为null,线程B就屁颠屁颠拿着得到的实例回去干活了，但是里头的成员变量还没初始化，这就尴尬了，报错也就理所当然了。
要解决这问题只要把instance设置成volatile，禁止重排序优化，以上面的例子，不管是1-2-3还是1-3-2，读取必须在操作完全执行完后才能进行。
public class Singleton {
private volatile static Singleton instance;
private Singleton (){}
public static Singleton getSingleton() {
if (instance == null) { //Single Checked
synchronized (Singleton.class) {
if (instance == null) { //Double Checked
instance = new Singleton();
}
}
}
return instance ;
}
}
然而在Java5以前的版本使用volatile还是有问题，也不能完全避免重排序。
public class Singleton{
private static final Singleton instance = new Singleton();
private Singleton(){}
public static Singleton getInstance(){
return instance;
}
}
由于instance被static和final修饰，在该类第一次被加载到内存中时就会对instance实例化，这样保证了单例。缺点是就算其他地方没有调用getInstance()方法，也会创建实例。
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
静态内部类就比较好的弥补了恶汉式单例不足，也是比较推崇的写法。
public enum EnumSingleton{
INSTANCE;
}
创建枚举默认就是线程安全的，所以不需要担心线程同步，而且还能防止反序列化导致重新创建新的对象。通过EnumSingleton.INSTANCE来访问实例，只是平时很少看到代码中有人这么写。
本文作者：HuYounger
本文标题：Java单例模式
本文链接：http://rkhcy.github.io/2017/03/29/Java单例模式/
发布时间：2017年3月29日 - 00时03分
版权声明：本文由 HuYounger 原创，采用保留署名-非商业性使用-禁止演绎 4.0-国际许可协议
转载请保留以上声明信息！
