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()

time	t1	t2	t3	t4	t5	t6
thread A	检测到singleton为空				初始化对象	返回对象
thread B		检测到singleton为空	初始化对象	返回对象

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

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

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. 初始化对象

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

time	t1	t2	t3	t4	t5	t6	t7	t8
thread A	检测到singleton为空	获取锁	再次判断为空	为singleton分配内存空间	将singleton指向内存空间			初始化singleton
thread B						检测到single未实例化	访问singleton(还未完成实例化)

在这种情况下，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）操作之前。

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