Java 并发：volatile、内存屏障与 CPU 缓存

二、volatile 关键字

volatile（中文：易变的），是 Java 里的一个关键字，修饰共享变量时，能解决上面说的可见性问题和有序性问题，但不能解决原子性问题。

类比一下：volatile，就是给 '冰箱里的菜' 贴了一张 '通知'——

• 你修改了冰箱里的菜（修改缓存数据），必须立刻把修改后的菜放回超市（主内存）；
• 其他人家的冰箱（其他 CPU 缓存）里，只要有这道菜（该变量），立刻失效，必须去超市（主内存）重新拿最新的；
• 同时，不准打乱 '拿菜、做菜、放菜' 的顺序（禁止指令重排序）。

1. volatile 的作用

作用 1：保证可见性，解决缓存同步问题

• 当一个线程修改了 volatile 修饰的共享变量，会强制将缓存里的修改后的数据，立刻写回主内存；
• 同时，会使其他线程缓存里的该变量副本失效，其他线程读取该变量时，必须从主内存重新读取（相当于 '强制刷新缓存'）。

还是上面的 count 例子，给 count 加 volatile 修饰：

private static volatile int count = 0;

此时，线程 1 修改 count=1 后，会立刻写回主内存，同时使线程 2 缓存里的 count 失效；线程 2 读取 count 时，会从主内存读到最新的 1，跳出循环 —— 可见性问题解决。

作用 2：保证有序性，禁止指令重排序

• CPU 为了提升效率，会对 '没有依赖关系' 的指令进行重排序（比如：先读 a，再读 b，可能被重排为 '先读 b，再读 a'）；
• volatile 会禁止这种重排序，保证 'volatile 修饰的变量' 的读写指令，按我们写的顺序执行（通过插入内存屏障实现）。

举个例子（单例模式双重检查锁，有序性问题）：

// 错误写法：instance 不加 volatile，可能出现空指针
public class Singleton {
    private static Singleton instance; // 不加 volatile
    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton(); // 这里可能重排序
                }
            }
        }
        return instance;
    }
}

instance = new Singleton() 实际被 CPU 拆分为 3 步：

1. 分配内存空间；
2. 初始化 Singleton 实例（调用构造方法）；
3. 把 instance 指向分配的内存空间（此时 instance != null）；

CPU 可能重排为：1→3→2—— 当线程 1 执行到 3（instance != null），但还没执行 2（未初始化），线程 2 进来，第一次检查 instance != null，直接返回 instance（未初始化），调用方法时出现空指针。

给 instance 加 volatile 修饰，会禁止这种重排序，保证 1→2→3 的顺序执行，避免空指针 —— 这就是 volatile 保证有序性的实际用途。

作用 3：不保证原子性

原子性，就是 '操作不可中断'—— 要么全部执行成功，要么全部不执行，中间不会被其他线程打断。

volatile不能保证原子性，比如 count++ 这种复合操作（拆分为：读 count、count+1、写 count），即使 count 被 volatile 修饰，多线程下依然会出现线程安全问题。

例子：10 个线程，每个线程执行 1000 次 count++，count 被 volatile 修饰：

private static volatile int count = 0;
public static void main(String[] args) throws InterruptedException {
    for (int i = 0; i < 10; i++) {
        new Thread(() -> {
            for (int j = 0; j < 1000; j++) {
                count++; // 复合操作，volatile 无法保证原子性
            }
        }).start();
    }
    Thread.sleep(2000);
    System.out.println("count 最终值：" + count); // 结果大概率小于 10000
}

因为 count++ 是 3 步操作，线程 1 读 count=0，还没执行 + 1 和写回，线程 2 也读 count=0，两者都执行 + 1，写回主内存都是 1—— 相当于少加了 1 次。

解决办法：用 synchronized、Lock，或者原子类（AtomicInteger），保证原子性。

2. volatile 的使用场景

1. 修饰 '状态标记变量'：比如 boolean flag = false; 一个线程修改 flag，另一个线程根据 flag 判断是否执行，用 volatile 保证可见性；
2. 单例模式双重检查锁（DCL）：修饰单例对象 instance，禁止指令重排序，避免空指针；
3. 修饰 '高频读取、低频修改' 的共享变量：比如配置信息，修改后所有线程能立刻看到最新配置。

三、内存屏障

前面说过，volatile 的可见性和有序性，都是通过内存屏障实现的 —— 内存屏障是 '底层 CPU 指令'，相当于 '指令之间的隔离带'，管住指令的执行顺序和缓存的同步。

1. 禁止屏障前后的指令重排序（前面的指令必须执行完，后面的才能执行）；
2. 强制刷新缓存（把缓存里的修改写回主内存，或从主内存重新读取缓存）。

1. 内存屏障的 4 种类型

CPU 层面的内存屏障有 4 种，Java 里 JVM 会根据不同的 CPU 架构，自动插入对应的内存屏障

3. volatile 插入内存屏障的规则

Java 中，volatile 变量的 '读写操作前后'，JVM 会自动插入 3 种内存屏障，保证可见性和有序性：

1. volatile 变量写操作后：插入 StoreStore 屏障 + StoreLoad 屏障；
   • StoreStore 屏障：保证 volatile 写操作，先于后面的所有写操作执行；
   • StoreLoad 屏障：保证 volatile 写操作完成后，立刻把数据写回主内存，同时使其他 CPU 缓存失效；
2. volatile 变量读操作前：插入 LoadLoad 屏障 + LoadStore 屏障；
   • LoadLoad 屏障：保证 volatile 读操作，读取的是主内存的最新数据；
   • LoadStore 屏障：保证 volatile 读操作完成后，再执行后面的写操作。

'volatile 底层是怎么实现可见性和有序性的？

volatile 的底层是通过插入内存屏障实现的。JVM 会在 volatile 变量的写操作后，插入 StoreStore 和 StoreLoad 屏障，强制将修改后的数据写回主内存，并使其他线程的缓存副本失效；在 volatile 变量的读操作前，插入 LoadLoad 和 LoadStore 屏障，强制从主内存读取最新数据。同时，内存屏障会禁止屏障前后的指令重排序，从而保证 volatile 的可见性和有序性。

四、三者关联总结

CPU 缓存导致了 '可见性和有序性问题'；volatile 关键字用来 '解决这两个问题'；而内存屏障是 'volatile 的底层实现手段'，通过禁止指令重排序、强制刷新缓存，帮 volatile 实现可见性和有序性。

五、常见问题

1. volatile 关键字的作用是什么？能保证原子性吗？为什么？

volatile 的作用是保证共享变量的可见性和有序性，不能保证原子性。可见性：修改 volatile 变量后，会立刻写回主内存，同时使其他线程的缓存副本失效，其他线程必须从主内存读取最新数据；有序性：通过插入内存屏障，禁止指令重排序，保证变量读写顺序和代码一致；不保证原子性：因为 volatile 无法解决 '复合操作（比如 count++）的中断问题'，复合操作拆分为多步，中间可能被其他线程打断，导致数据错乱。

2. volatile 底层是怎么实现的？和内存屏障有什么关系？

volatile 的底层是通过插入内存屏障实现的。JVM 会在 volatile 变量的写操作后，插入 StoreStore 和 StoreLoad 屏障，强制将修改后的数据写回主内存，使其他线程缓存失效；在 volatile 变量的读操作前，插入 LoadLoad 和 LoadStore 屏障，强制从主内存读取最新数据。内存屏障的核心作用是禁止指令重排序、强制刷新缓存，这正是 volatile 实现可见性和有序性的关键，相当于 'volatile 是上层关键字，内存屏障是底层实现手段'。

3. CPU 缓存为什么会导致可见性问题？怎么解决？

因为 CPU 运算速度远快于主内存，CPU 会优先操作缓存里的数据，不会实时将缓存数据同步到主内存；其他线程读取数据时，会从自己的 CPU 缓存读取，而不是主内存，导致多个线程看到的同一个变量不一致，引发可见性问题。解决办法：用 volatile 修饰共享变量，通过内存屏障强制缓存同步和禁止重排序；或者用 synchronized、Lock，保证同一时刻只有一个线程修改变量，同时释放锁时会刷新缓存。