双重检索(DCL)的思考: 为什么要加volatile?

在学习单例模式的时候, 小伙伴们都会学习到一种叫作双重检索的单例模式, 如下

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;
    }
}
           

可以看到, 当多个线程同时去调用getInstance方法时, 如果instance还没初始化, 即instance == null, 线程进入第一个if方法, 然后会有一个线程率先拿到锁, 其他线程开始等待, 此时instance == null。拿到锁的线程进入到同步方法并进入第二个if方法里, 先通过new的方式初始化一个实例, 之后再释放锁, 此时instance != null。与此同时刚刚等待的线程开始竞争锁, 拿到锁的线程进入到同步方法里, 发现此时instance已经初始化过了, 所以就不进入第二个if方法, 直接返回已经初始化过的instance。后续如果再有线程调用getInstance方法, 在第一个if判断那里就为false, 直接返回刚刚已经初始化过的instance了, 这样做的好处是: 保证了线程安全, 避免了多个线程同时调用getInstance方法时, 每次都在竞争锁, 增加系统的开销。

下面进入正题, 我们在定义instance时, 增加了volatile关键字, 它的作用是什么呢? 不加可不可以?

这里就要先从计算机指令讲起, CPU和编译器为了提升程序的执行效率, 通常会按照一定的规则对指令进行优化, 如果两条指令互不依赖, 有可能它们执行的顺序并不是源代码编写的顺序。

比如正常情况下 instance = new Instance()可以分成三步:

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

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

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

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

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

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

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

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

这个问题我讲清楚了吗? 欢迎留言!