单例模式中懒汉式的线程安全问题

代码示例：

public class Singleton {
    private volatile static Singleton instance;

    private Singleton(){}

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

两个疑问

1.为什么要用双重检查锁定？

• 如果锁加在getInstance静态方法上，每次调用getInstance()时
  都需要进行线程锁定判断，在多线程高并发访问环境中，将会导致系统性能大大降低。
• 加入双重检查锁定后，在第一个初始化后后面的调用将不会进入第一个if，即不会进一步进行线程锁定判断。
  例如：
• 有1万次getInstance()的调用
• 在第一个获得锁，初始化，解锁的时间里，有100个进入第一个if，那么系统只需要做100次线程锁定判断，后续的调用则在第一个if中被排除，与原来的1万次线程锁定判断则大大提高了效率。

2. 为什么要加volatile

这里就要先从计算机指令讲起, CPU和编译器为了提升程序的执行效率, 通常会按照一定的规则对指令进行优化, 如果两条指令互不依赖, 有可能它们执行的顺序并不是源代码编写的顺序。
比如正常情况下 instance = new Instance()可以分成三步:

1. 分配对象内存空间。
2. 初始化对象。
3. 设置instance指向刚刚分配的内存地址, 此时instance != null (重点)。

因为2, 3步不存在数据上的依赖关系,
即在单线程的情况下, 无论2和3谁先执行, 都不影响最终的结果, 所以在程序编译时, 有可能它的顺序就变成了

1. 分配对象内存空间
2. 设置instance指向刚刚分配的内存地址, 此时instance != null (重点)
3. 初始化对象

CPU和编译器在指令重排时, 并不会关心是否影响多线程的执行结果。
在不加volatile关键字时, 如果有多个线程访问getInstance方法, 此时正好发生了指令重排, 那么可能出现如下情况:

1. 当第一个线程拿到锁并且进入到第二个if方法后, 先分配对象内存空间,
2. 然后再instance指向刚刚分配的内存地址, instance 已经不等于null, 但此时instance还没有初始化完成。
3. 如果这个时候又有一个线程来调用getInstance方法, 在第一个if的判断结果就为false,
4. 于是直接返回还没有初始化完成的instance, 那么就很有可能产生异常。

那么加了volatile之后会有什么不同呢? volatile有三个特点:

1. 保证可见性
2. 不保证原子性
3. 禁止指令重排

加了volatile关键字之后, 会强制cpu和编译器按照顺序执行代码, 所以就不用担心指令重排导致上面的问题了。