目录

一、前置知识：Java 内存模型 (JMM)

二、volatile 保证：内存可见性

1. 可见性问题（无 volatile）

2. volatile 可见性底层原理

3. 底层实现：内存屏障 + 缓存一致性协议

三、volatile 核心：禁止指令重排（重点）

1. 什么是指令重排？

2. volatile 如何禁止指令重排？

屏障规则（固定口诀）

3. 硬件底层：lock 前缀指令

四、volatile 三大核心特性总结

重要提醒：volatile 不保证原子性

五、volatile 使用场景

总结

---

volatile 是 Java 并发编程的轻量级同步机制，它不保证原子性，但能保证两个核心特性：

1. 内存可见性：一个线程修改了变量，其他线程能立即读到最新值
2. 禁止指令重排：保证代码执行顺序和代码编写顺序一致（有序性）

本文会从Java 内存模型 (JMM) → 可见性原理 → 指令重排原理 → 底层 CPU 指令 逐层讲透。

---

一、前置知识：Java 内存模型 (JMM)

要理解 volatile，必须先搞懂线程工作内存 vs 主内存：

1. 主内存：所有线程共享的内存，存储变量真实值
2. 工作内存：每个线程私有的本地内存，只存储变量的副本

线程修改变变量的流程：读取主内存副本 → 工作内存修改 → 写回主内存问题：修改后不会立即同步到主内存，其他线程也不会立即感知，导致脏数据。

---

二、volatile 保证：内存可见性

1. 可见性问题（无 volatile）

// 线程1
boolean flag = false;
while (!flag) { }  // 死循环

// 线程2
flag = true;  // 线程1可能永远感知不到

线程 2 修改flag=true只写在自己的工作内存，没同步到主内存；线程 1 一直读旧副本。

2. volatile 可见性底层原理

当变量被volatile修饰：

1. 写操作：线程修改后，立即强制刷新到主内存
2. 读操作：线程读取前，强制让本地副本失效，重新从主内存读取

3. 底层实现：内存屏障 + 缓存一致性协议

• CPU 层级：依赖MESI 缓存一致性协议，多 CPU 核心间嗅探数据变化，强制缓存同步
• JVM 层级：插入内存屏障（Memory Barrier），控制指令执行和内存同步

---

三、volatile 核心：禁止指令重排（重点）

1. 什么是指令重排？

CPU / 编译器为了优化性能，在不影响单线程结果的前提下，打乱代码执行顺序。单线程没问题，多线程会导致严重 bug。

经典例子：DCL 单例双重检查锁

public class Singleton {
    // 不加volatile会出bug！
    private static Singleton instance; 
    
    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    // 这行代码会被指令重排！
                    instance = new Singleton(); 
                }
            }
        }
        return instance;
    }
}

instance = new Singleton() 真实分为 3 步：

1. 分配内存空间
2. 初始化对象
3. 将 instance 指向内存地址

指令重排后可能变成 1→3→2：线程 A 执行到 3（对象未初始化），线程 B 判断instance!=null，直接使用未初始化的对象，崩溃。

---

2. volatile 如何禁止指令重排？

答案：内存屏障（Memory Barrier）JMM 定义了 4 种内存屏障，volatile 读写时会自动插入屏障，禁止 CPU / 编译器重排跨越屏障。

屏障规则（固定口诀）

1. volatile 写之前：插入StoreStore屏障 → 禁止前面的写和当前写重排
2. volatile 写之后：插入StoreLoad屏障 → 禁止当前写和后面的读重排（最核心、最耗性能）
3. volatile 读之后：插入LoadLoad屏障 → 禁止当前读和后面的读重排
4. volatile 读之后：插入LoadStore屏障 → 禁止当前读和后面的写重排

最终效果：

• volatile 变量前面的代码一定在它之前执行
• volatile 变量后面的代码一定在它之后执行
• 指令重排不能跨越 volatile 屏障

---

3. 硬件底层：lock 前缀指令

Java 代码最终会编译为 CPU 指令，volatile 的底层实现是：对 volatile 变量的写操作，会生成带 lock 前缀的 CPU 指令

lock指令有两个作用：

1. 强制将缓存数据刷新到主内存（保证可见性）
2. 禁止指令重排（CPU 执行 lock 指令时，会等待前面所有指令执行完毕，阻塞后面指令乱序执行）

这就是 volatile 禁止重排的硬件底层原理。

---

四、volatile 三大核心特性总结

特性	volatile 是否支持	底层原理
可见性	✅ 支持	内存屏障 + 缓存刷新 + MESI
有序性	✅ 支持	内存屏障禁止指令重排
原子性	❌ 不支持	无法保证复合操作不可中断

重要提醒：volatile 不保证原子性

volatile int i = 0;
// 多线程下 i++ 会出错！
// 因为 i++ = 读i → 加1 → 写i 三步操作，volatile只保证每步可见，不保证整体原子
i++; 

需要原子性 → 用 synchronized 或 AtomicInteger。

---

五、volatile 使用场景

1. 状态标记量（线程启停、flag 标记）
2. DCL 双重检查锁单例（必须加 volatile）
3. 独立的状态变量（无需原子操作，只需可见 + 有序）

---

总结

1. 可见性：volatile 强制读写同步主内存，线程间立即感知
2. 禁止指令重排：通过内存屏障+lock 前缀指令，严格限制指令执行顺序
3. 底层：JMM 内存屏障 + CPU 缓存一致性协议 (MESI) + lock 指令
4. 定位：轻量级同步，只保证可见性 + 有序性，不保证原子性