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

本文深入解析双重检索单例模式中volatile关键字的作用,解释为何在多线程环境下,volatile能防止指令重排,确保线程安全。通过具体代码示例,说明不使用volatile可能导致的异常情况。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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

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和编译器按照顺序执行代码, 所以就不用担心指令重排导致上面的问题了。
这个问题我讲清楚了吗? 欢迎留言!

<think>我们正在讨论双重校验锁单例模式volatile关键字的作用。根据提供的引用,特别是引用[1]、[2]、[3]、[4]、[5],我们可以总结出以下关键点:1.**双重检查锁定(DCL)的目的**:在保证线程安全的同时,减少同步带来的性能开销。通过两次检查(一次在同步块外,一次在同步块内)来确保只有在实例未初始化时才进行同步创建。2.**为什么需要volatile**:主要原因是防止指令重排序(instructionreordering)导致的线程安全问题。在Java中,创建一个对象(`instance=newSingleton();`)并不是一个原子操作,它分为三个步骤:-分配内存空间-初始化对象(调用构造函数)-将实例引用指向分配的内存地址但是,由于指令重排序的优化,步骤2和步骤3可能会被重新排序。也就是说,可能出现先分配内存空间,然后将引用指向该内存,最后才初始化对象的情况。3.**重排序带来的问题**:假设有两个线程A和B:-线程A进入同步块,执行`instance=newSingleton();`,此时由于重排序,对象还未初始化完成,但引用已经不为null(即已经指向了分配的内存地址)。-此时线程B调用`getInstance()`,在第一次检查`instance==null`时发现不为null,于是直接返回`instance`,但此时`instance`指向的对象还未初始化完成(构造函数未执行完),导致线程B使用了一个不完整的对象。4.**volatile的作用**:-禁止指令重排序:使用volatile修饰的变量,会插入内存屏障(MemoryBarrier),确保写操作之前的指令不会被重排序到写操作之后,读操作之后的指令不会被重排序到读操作之前。-保证可见性:当一个线程修改了volatile变量的值,其他线程能立即看到修改后的值。在单例模式中,volatile修饰的`instance`变量,可以确保在对象初始化完成之后,才将引用赋值给`instance`,从而避免其他线程看到未初始化的对象。5.**引用中的说明**:-引用[1]和[2]指出volatile主要是为了保证线程安全,避免指令重排序问题。-引用[3]和[4]强调volatile防止了JVM的指令重排序,确保单例对象只会被创建一次。-引用[5]详细解析了指令重排序导致的问题以及volatile如何解决。因此,在双重校验锁单例模式中,`volatile`关键字是必需的,它解决了由于指令重排序导致的线程安全问题。###总结:-**没有volatile**:可能发生指令重排序,导致其他线程获取到未完全初始化的实例。-**使用volatile**:禁止与实例创建相关的指令重排序,保证对象初始化完成后再赋值给引用,从而确保线程安全。###相关问题:1.除了双重检查锁,还有哪些线程安全的单例实现方式?2.volatile关键字在Java内存模型(JMM)中还有哪些作用?3.为什么双重检查锁中需要两次判空?4.指令重排序在哪些情况下会发生?</think>### 双重校验锁单例模式中 `volatile` 关键字的作用解析 在双重检查锁定(Double-Checked Locking, DCL)实现单例模式时,`volatile` 关键字的核心作用是**防止指令重排序**,确保多线程环境下对象初始化的原子性和可见性。以下是详细解析: #### 1. **对象创建的非原子性问题** 对象实例化 `instance = new Singleton()` 包含三个关键步骤: 1. 分配对象内存空间 2. 初始化对象(调用构造函数) 3. 将引用指向内存地址 ```java instance = new Singleton(); // 非原子操作 ``` 在没有 `volatile` 的情况下,JVM 可能对指令进行重排序,将步骤3提前到步骤2之前执行(即先分配地址再初始化)。这种重排序在单线程中无影响,但在多线程中会导致严重问题。 #### 2. **多线程下的失效场景** 假设线程A执行创建操作时发生指令重排序: 1. 分配内存空间 2. **将引用指向内存地址(此时 instance ≠ null)** 3. 初始化对象(构造函数未完成) 此时线程B调用 `getInstance()`: ```java if (instance == null) { // 判断为 false(因为引用已存在) return instance; // 返回未初始化的半成品对象! } ``` **结果**:线程B获得了一个未完成初始化的对象,可能导致空指针异常或状态错误。 #### 3. **`volatile` 的解决方案** 通过 `volatile` 修饰实例变量: ```java private static volatile Singleton instance; ``` 该关键字实现两个关键保障: 1. **禁止指令重排序** 在写操作前后插入内存屏障(Memory Barrier),确保: - 对象完全初始化完成 - **之后**才将引用赋值给 `instance` 2. **保证可见性** 确保一个线程修改 `instance` 后,其他线程能立即看到最新值(通过主内存同步) #### 4. **内存屏障原理** `volatile` 在字节码层面生成以下屏障: ``` StoreStore Barrier // 阻止初始化操作之前的写重排序 初始化对象 StoreLoad Barrier // 阻止初始化与引用赋值的重排序 赋值 instance LoadLoad Barrier // 确保后续读操作能看到完整对象 ``` #### 5. **与普通锁定的对比** | 方案 | 性能 | 线程安全 | 初始化时机 | |--------------------|------------|----------|------------------| | 同步方法锁 | 差(每次调用锁) | 安全 | 首次调用 | | 双重检查锁无volatile | 好 | **不安全** | 首次调用 | | 双重检查锁+volatile | 好 | 安全 | 首次调用 | > 引用[5]明确指出:*"volatile 可以防止某些 JVM 在多线程环境中可能出现的指令重排序问题,确保单例对象只会被创建一次"*[^5]。 ### 总结 `volatile` 在 DCL 单例模式中是**必需的**,它解决了以下问题: 1. **防止指令重排序** → 避免返回未初始化的对象 2. **保证内存可见性** → 确保所有线程看到一致状态 3. **维持性能优势** → 仅在首次初始化时同步 > 引用[3]强调:*"虽然之前了解了双重检查锁定模式的原理,但是却忽略变量使用了 volatile"*[^3],这恰恰是线程安全的关键所在。 ```mermaid sequenceDiagram participant ThreadA as 线程A(创建者) participant Memory as 主内存 participant ThreadB as 线程B(使用者) ThreadA->>Memory: 1.分配内存 ThreadA->>Memory: 2.初始化对象(构造函数) ThreadA->>Memory: 3.volatile写屏障(禁止重排) ThreadA->>Memory: 4.赋值instance Memory-->>ThreadB: 5.volatile读屏障(强制同步) ThreadB->>Memory: 6.安全获取完整对象 ```
评论 15
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值