volatile 关键字

kfkfka🍀zkye2025/2/3...大约 10 分钟

volatile 关键字

面试鸭-Java中volatile关键字的作用是什么？保证变量可见性和部分有序性。
面试鸭-什么是Java中的指令重排序？Java编译器和处理器为优化性能，在保证单线程程序语义不变的情况下，对指令执行顺序进行重新调整。
volatile 直接翻译成中文，最常见的、能体现其“易变”或“不稳定”含义的词是：
易变的 (yì biàn de) - 这个最直接，表示容易改变。
不稳定的 (bù wěndìng de) - 也体现了其值可能随时会变动，不固定的性质。
易挥发 (yì huīfā) - 这是从化学中的“易挥发物质”引申过来的意思，指容易蒸发、转变成气体。在计算机领域有时也用这个词，带有值容易“飘走”、“丢失”或被覆盖的隐喻。
易失 (yì shī) - 这个词在计算机领域常用于“易失性内存 (volatile memory)”，指断电后数据会丢失的内存（如 RAM）。
在 Java 多线程的上下文中，volatile 强调的是变量的可见性，即一个线程对它的修改能立刻被其他线程看到。这里的“易变”或“不稳定”是指这个变量的值不受 CPU 缓存的束缚，总是直接从主内存读取，因为它“可能被其他线程随时改变”，所以它的值是“易变的”、“不稳定的”，不能假设它在缓存中是最新或一致的。
所以，最能直接翻译其含义并适用于编程上下文的是 易变的 或 不稳定的，而 易挥发 也是一个常用但略带比喻色彩的翻译。

volatile 保证可见性的含义是：当一个线程修改了某个 volatile 变量的值时，该新值会立即对其他线程可见，即其他线程读取该变量时会直接从主内存中获取最新值，而非使用本地缓存的旧值。

[!NOTE]
记住，在一般情况下，线程在 CPU 核心中执行，优先读取离 CPU 核心最近的寄存器/高速缓存，而最新数据可能更新在主存中未及时同步到相应的 CPU 寄存器/高速缓存中。

volatile 是 Java 中的一个类型修饰符，主要用于多线程环境。它确保变量的可见性（Visibility）和部分有序性（Ordering），但不保证原子性（Atomicity）。

核心概念：

在多核处理器系统中，每个处理器可能有自己的高速缓存（Cache）。线程在执行时，通常会先将变量的值从主内存读取到自己的工作内存（Working Memory，可以理解为 CPU Cache），然后对变量进行操作，最后再将修改后的值写回主内存。

这就可能导致以下问题：

可见性问题： 一个线程修改了共享变量的值，但这个修改后的值可能只存在于该线程的工作内存中，而其他线程的工作内存中仍然是旧值。这导致其他线程无法立即看到最新的值。
有序性问题： 为了提高性能，编译器和处理器可能会对指令进行重排序，只要重排序后的执行结果在单线程环境下与原顺序一致即可。但在多线程环境下，这种重排序可能会导致意外的结果。

volatile 关键字就是用来解决这些问题的：

保证可见性:
- 当一个变量被声明为 volatile 时，它指示 JVM：这个变量的值是“易变的”，每次使用它时都必须从主内存中读取，每次修改它时都必须立即刷新到主内存。
- 这确保了所有线程都能看到该变量的最新值，因为它绕过了线程本地的工作内存缓存，直接与主内存交互。
保证部分有序性（禁止指令重排序）:
- volatile变量的读写操作会插入特殊的内存屏障（Memory Barrier），以禁止特定类型的指令重排序：
  - 在一个 volatile 写操作之前的所有普通写操作，都必须在其之前完成，并且写到主内存中。
  - 在一个 volatile 写操作之后的所有普通读写操作，都不能被重排序到 volatile 写操作之前。
  - 在一个 volatile 读操作之后的所有普通读写操作，都不能被重排序到 volatile 读操作之前。
  - 在一个 volatile 读操作之前的所有普通读操作，都必须在其之前完成。
- 简单来说，一个 volatile 写操作之前的操作，对其他线程是可见的；一个 volatile 读操作之后的代码，会看到最新的 volatile 值。这建立了一种“happens-before”关系，确保了操作的顺序性。

volatile 与 synchronized 的区别：

volatile:
- 只作用于变量。
- 只保证可见性和部分有序性。
- 不保证原子性。
- 开销相对较小。
synchronized:
- 作用于代码块或方法。
- 既保证可见性（线程进入 synchronized 块前，会刷新工作内存；退出时，会将工作内存的修改写回主内存）
- 也保证原子性（同一时间只有一个线程可以进入 synchronized 块/方法）。
- 开销相对较大，因为它涉及锁的获取和释放。

volatile 的局限性（不保证原子性）：

尽管 volatile 保证了可见性，但对于复合操作（如 i++，它实际上包含读取 i、i+1、写入 i 三个步骤），volatile 并不能保证原子性。

例如：

class Counter {
    volatile int count = 0;

    public void increment() {
        count++; // 这不是原子操作
    }
}

在多线程环境下，如果两个线程同时调用 increment()：

线程 A 读取 count (假设为 0)。
线程 B 读取 count (假设为 0)。
线程 A 计算 0 + 1 = 1。
线程 B 计算 0 + 1 = 1。
线程 A 将 1 写回主内存 (count 变为 1)。
线程 B 将 1 写回主内存 (count 仍然变为 1)。

最终结果 count 变成了 1，而不是期望的 2。这是因为 count++ 不是原子操作，虽然 count 是 volatile 的，保证了读写的可见性，但在读和写之间的步骤（加 1）不是原子的。

要解决这种原子性问题，需要使用 synchronized 或 Java 并发包中的原子类（如 AtomicInteger）。

何时使用 volatile？

volatile 通常用于以下情况：

**标记状态或标志变量：**当一个变量被多个线程共享，用于表示某种状态或作为控制标志时，并且对该变量的操作是简单的赋值（如布尔标志），不需要依赖其当前值进行计算（如flag = true;）。

volatile boolean shutdownRequested = false;

public void shutdown() {
    shutdownRequested = true; // volatile 写
}

public void doWork() {
    while (!shutdownRequested) { // volatile 读
        // do work
    }
}

单例模式的双重检查锁定（DCL）： 在实现线程安全的单例模式时，保证instance的写操作对其他线程立即可见，为了防止指令重排序导致返回一个尚未完全初始化的对象，通常会将单例实例变量声明为 volatile。
```
public class Singleton {
  private static volatile Singleton instance;
  
  // 私有化构造方法，防止外部实例化
  private Singleton() {
    // 一些特定实现
  }
  
  public static Singleton getInstance() {
    if (instance == null) {
      synchronized (Singleton.class) {
        if (install == null) {
          instance = new Singleton();
        }
      }
    }
    return instance;
  }
}
```
说明：因为instance = new Singleton()是一个非原子操作，分为以下三步：
1. 分配内存空间赋默认值
2. 初始化对象
3. 将对象的引用赋值给instance
在没有volatile的情况下，编译器和CPU可能会对这些步骤进行指令重排序（如a->c->b），此时，另外一个线程可能会在instance被赋值后，但对象尚未完成初始化时访问它，从而导致出错。

总结：

volatile 是一个重要的并发关键字，它解决了多线程环境下变量的可见性和部分有序性问题，通过强制变量的读写直接与主内存交互并插入内存屏障。但是，它不保证原子性，因此不适用于需要进行复合操作（如 i++）的场景。理解 volatile 的作用和局限性，是编写正确、高效并发程序的基础。

volatile 保证可见性是什么意思，体现在系统底层的区别是什么

volatile 保证可见性的含义是：当一个线程修改了某个 volatile 变量的值时，该新值会立即对其他线程可见，即其他线程读取该变量时会直接从主内存中获取最新值，而非使用本地缓存的旧值。

可见性的具体体现

主内存与线程本地缓存的差异
- 普通变量：线程读取变量时，优先从本地缓存（如 CPU 寄存器或高速缓存）读取，可能导致线程间数据不一致。
- volatile 变量：线程读取时强制从主内存加载，写入时立即刷新到主内存，确保所有线程看到的是同一份最新值。
禁止指令重排序
volatile 通过插入**内存屏障（Memory Barrier）**防止编译器和处理器对指令进行重排序，从而保证变量读写操作的顺序性。
- 写屏障（Store Barrier）：在写操作后插入，确保写操作先于后续操作刷新到主内存。
- 读屏障（Load Barrier）：在读操作前插入，确保读操作先于后续操作加载主内存数据。

系统底层的区别

缓存一致性协议
在多核 CPU 架构中，volatile 变量的读写会触发缓存一致性协议（如 MESI 协议），确保不同核心的缓存状态同步：
- 当线程 A 修改 volatile 变量时，会标记该变量在其他核心的缓存为无效，迫使其他线程重新从主内存加载。
- 普通变量则可能因缓存未失效导致线程读取到过期值。
内存屏障的硬件实现
- 写屏障：通过 sfence 指令（x86 架构）强制将写缓冲区的数据刷新到主内存。
- 读屏障：通过 lfence 指令（x86 架构）清空无效缓存行，强制从主内存读取。
- 这些指令直接作用于 CPU 的内存管理单元（MMU），确保数据可见性和顺序性。
JVM 层面的实现
JVM 在生成字节码时，会对 volatile 变量的读写操作插入特定的内存屏障指令，屏蔽不同硬件架构的差异性。例如：
- putfield 或 putstatic 指令（写操作）后插入 StoreStore 和 StoreLoad 屏障。
- getfield 或 getstatic 指令（读操作）前插入 LoadLoad 和 LoadStore 屏障。

典型应用场景

状态标志：用于多线程间共享状态的切换（如 volatile boolean shutdownRequested）。
双检锁单例模式：确保单例对象的初始化对所有线程可见。
事件监听器：保证事件状态变更的实时通知。

局限性

不保证原子性：volatile 仅保证单次读写操作的原子性，但无法保证复合操作（如 i++）的原子性。此时需使用 synchronized 或 AtomicInteger 等原子类。
性能开销：频繁访问 volatile 变量会导致频繁的主内存读写，可能影响性能。

总结

通过 volatile 的可见性保障机制，Java 在语言层面屏蔽了底层硬件和操作系统的复杂性，为多线程编程提供了轻量级的同步工具。