作者： 一字马胡
转载标志 【2017-11-03】

更新日志

日期	更新内容	备注
2017-11-03	添加转载标志	持续更新

我们经常需要使用单例模式来为我们工作，而我们一般会使用下面的代码来组织我们的单例模式：

public class SingletonClass {
   private static SingletonClass _instance = null;
  
   private SingletonClass() {}
   
   public static SingletonClass getInstance() {
        if (_instance == null) {
             synchronized(SingletonClass.class) {
             if (_instance == null) {
                   _instance = new SingletonClass();
              }
           }
        }
   }
} 

我们称这样的代码为“双重检查锁定”(Double checking locking)，一般情况下，这样的代码不会出现什么问题，毕竟我们的代码中也有类似的代码，但是这样的代码还是会有安全隐患。在这里，我们需要了解一个“new SingletonClass()”背后的过程，新生成一个对对象需要三个过程：

1、申请足够大小的内存空间
2、初始化申请到的内存空间
3、将新对象指向申请的内存空间

如果按照1-2-3的顺序来的话是没有问题的，但是编译器有可能会为了达到最好的效率对指令进行重排序，对于不会影响执行结果的指令，编译器可以进行指令冲排序，上面的2和3之间没有依赖关系，所以可以进行重排序，所以最后new的动作的执行顺序可能为1-3-2，而只要3执行了，那么我们的对象就不是null了啊，虽然还没有初始化。而问题就在这里，假设线程A执行到了“new SingletonClass（）”这一句，然后new动作的指令被重新排序为1-3-2，我们假设线程A执行到3的时候（还没有执行2），线程B来检测“_instance == null”，而线程A已经使得“_instance != null”成立了，所以线程B不再继续执行，但是我们发现线程B获取到的是一个还没有初始化的对象实例，这样做是有安全隐患的，假若线程B获取到_instance之后立刻操作这个对象就会出现问题。
经过我们的分析，我们发现问题在于new的指令被编译器重排序了，我们有两种方法来解决上面的问题：

一、使用volatile来禁止指令重新排序

public class SingletonClass {
   private static volatile SingletonClass _instance = null;
  
   private SingletonClass() {}
   
   public static SingletonClass getInstance() {
        if (_instance == null) {
             synchronized(SingletonClass.class) {
             if (_instance == null) {
                   _instance = new SingletonClass();
              }
           }
        }
   }
} 

只需在_instance之前加上volatile，我们就可以解除安全隐患。

二、使用类初始化特性来解决，JVM在进行类初始化时，JVM会去获取一个锁，可以同步多个线程对同一个类的初始化。这也是我们在代码里面见到最多的方式（正确的）。

1、使用final关键字达到我们想要的效果

final关键字保证：只要对象是被正确构造的，也就是在构造函数中没有“逸出”，那么多个线程都能看到构造函数中被初始化的值，也就是可以不使用锁（synchronized等）就可以达到同步的效果，关于“逸出”，指的是对象还没有被构造完成之前就被引用，比如下面的代码：

public class EscapeClass {
  
    private static final int value;
    private static EscapeClass _instance;

    public EscapeClass(int i)  {
         value = i; //initialize the final value
          _instance = this; // escape here
    }

   public static int getValue()  { 
        if (_instance != null) {  
             return _instance.value;  
       } else {
           return 0;
      }
    }
   public static void init()  { 
         new EscapeClass(); 
    }

}

在上面的类EscapeClass中，构造函数里出现了对象引用“逸出”，假设有两个线程，一个线程A执行init方法，而另外一个线程B执行getValue方法，在EscapeClass的构造函数里面的两个操作可能会被重新排序，所以可能首先执行了对象引用:_instance = this的操作，而此时final域还没有被初始化，value的值还不是我们想要的，但是线程B在执行getValue方法的时候发现_instance != null已经成立了，所以他就直接返回了_instance.value，但是实际上EscapeClass构造函数没有执行完成，线程B取到的值不是预期的值，主要的问题还是在指令重排序。
理解了什么是“逸出”，就可以来看下面的代码了，因为SingletonClass的构造函数里面什么都没干，所以不会发生“逸出”的危险。

private class SingletonClass {
   
    private static final SingletonClass _instance = new SingletonClass();

    private SingletonClass() {}

    public static SingletonClass getInstance() {
        return _instance;
    }

}

2、更为一般的写法如下(推荐)：

private class SingletonClass {
  
   private static SingletonClass InstanceHolder {
          public static SingletonClass DEFAULT = new SingletonClass();
   }

    private SingletonClass() {}

    public static SingletonClass getInstance() {
        return  InstanceHolder.DEFAULT;
    }

}

假设有两个线程同时需要初始化类SingletonClass，那么都需要首先获取一个锁，获取锁成功的线程可以进行初始化工作，没有获取到的线程只能等待，而同一个线程内new的指令重排序是不影响最后结果的。