双重检查锁定

双重检查锁定 - Double checked locking，是一种单例的方式。这种写法的关键在于用 volatile描述实例对象，同时在 synchronized块外面和里面判断实例对象是否为空。

面试中经常有一个问题，DCL中的volatile关键字是否能不用呢？ 回答这个问题，需要明白 volatile关键字的特性中的有序性。

并发要素--有序性

并发三要素包括原子性 / 有序性 / 可见性。其中的有序性意思是指令的执行顺序不会被重新排列。来看看下面的代码

Demo 1

x = 1; //1
y = 2; //2
z = 3; //3

上面这三行代码，运行时可能会被虚拟机优化，从而执行顺序变成 2->1->3。优化的原则是不影响结果，如下面这段代码，则不会被重排序，

Demo 2

x = 0;
x = 1; //1
y = x; //2
z = 3; //3

假如优化为 2->1->3的话，则y的结果就错误了。假若对 y加上 volatile关键字的话，那么Demo 1中的执行顺序就不会被重排序了，这就是 volatile的有序性。

再来看经常用在状态初始化相关的代码，

//线程1:
context = loadContext();   //语句1
inited = true;             //语句2

//线程2:
while(!inited ){
  sleep()
}
doSomethingwithconfig(context);

因为1和2并不互相依赖，所以可能存在被重排序的问题。这样就会导致在初始化的时候，线程2的inited变为true，而 context还没初始化完。

上面这些跟我们的单例有什么关系呢？来看下面的代码。

volatile对DCL的作用

有序性对DCL的作用，其实作用在对象的实例化过程。一个普通的DCL会像下面代码这样，

public class Singleton  {
    private static volatile Singleton mInstance = null;
    private Singleton{}
    public static Singleton getIsntance() {
      if(mInstacen == null){
        synchronized(Singleton.class){
          if(mInstacen == null){
            mInstacen = new Singleton();
          }
        }
      }
      return mInstacen;
    }
}

我们先解释下在不使用 volatile修饰的情况下可能发生单例失效的原因。问题出在 mInstance = new Singleton()这一句，当实例化的时候，其实分为三个步骤

//伪代码
memory = allocate();//1
ctorInstance(memory);//2
instance = memory;//3

上面是真实发生的实例化过程，在某些编译器上在发生指令重排序之后，可能变成下面这样

//伪代码
memory = allocate();//1
instance = memory;//3
ctorInstance(memory);//2

依据JAVA重排序的前提条件，重排序后的结果不受影响，但是就会导致单例失效的问题。因为其他线程在进入第二个null判断时mInstance仍然为null，从而再次实例化。可以认为在实例化的//3语句结束后就释放了锁，因此重排序会导致在mInstance仍然为null的时候第二个线程就进入了。 volatile在阻止了重排序之后，第二个线程只能在 instance正确初始化并不为 null的情况下才能获取锁，所以 volatile避免了DCL被破坏的情况。

总结

DCL - double checked locking之所以需要 volatile，是因为它能阻止指令重排序，从而避免其他线程在进入同步块的时候对象仍然为null的情况发生。