java中的DCL双重检查锁（double checked locking）

DCL 双重检查锁（double checked locking）
在实现单例模式时，未考虑多线程的情况下就容易写出如下的错误代码：

public class Singleton {
    private static Singleton singleton;private Singleton() {
    }public Singleton getInstance() {
    if (null == singleton) {
    singleton= new Singleton();}return singleton;}
}

在多线程的情况下两个线程同时调用getInstance()

可看出实例出两个对象，违背了单例原则；

加锁
出现这种情况自然考虑到要加锁

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

直接加载方法上虽然可以解决问题，但导致了很大的性能开销，且只有在初始化的时候需要加锁，这样在后续每次的调用都被加锁，性能开销太大，此时考虑使用代码块进行细粒度的锁定；

public class Singleton {
    private static Singleton singleton;private Singleton() {
    }public Singleton getInstance() {
    if (null == singleton) {
    synchronized(this){
    singleton= new Singleton();}}return singleton;}
}

这样同样有问题，如果两个线程同时通过判断对象是否已被实例化，一个线程先获取到锁并实例化对象，那么后续另一个线程获取到锁后也会再次实例化一次，因此单次检查是不够的，由此引出是否可以多加一次检查；

public class Singleton {
    private static Singleton singleton;private Singleton() {
    }public Singleton getInstance() {
    if (null == singleton) {
    synchronized(this){
    if (null == singleton) {
    singleton= new Singleton();}}}return singleton;}
}

到了这里应该说这个在多线程访问下的单例应该完美了，但实际上仍然有很大问题，或者说隐患；
在new Singleton()的时候，实际上这个操作不是原子的，实际分成了3步完成；

1. 分配内存空间
2. 初始化对象
3. 将对象指向刚分配的内存空间

但有些编译器为了优化性能，就会出现第2步和第3步的顺序调换，即重排序；

1. 分配内存空间
2. 将对象指向刚分配的内存空间
3. 初始化对象

考虑重排序后时序变成如下

在这种情况下，T7时刻thread B对singleton的访问,实际访问的是一个初始化未完成的对象。

正确的双重检查锁

public class Singleton {
    private volatile static Singleton singleton;private Singleton() {
    }public Singleton getInstance() {
    if (null == singleton) {
    synchronized(this){
    if (null == singleton) {
    singleton= new Singleton();}}}return singleton;}
}

在singleton前加入关键字volatile。
使用了volatile关键字后，重排序被禁止，所有的写（write）操作都将发生在读（read）操作之前。

至此，一个适用于多线程的单例就可以完美工作了！