← 课程目录 🚀 从零到一
📐 学习维度 阶段2 · 第7章 并发编程 🚀 从零到一 📚 课程目录 🏠 首页 🛤️ 学习路径

7.2 JMM 与 volatile:为什么你改的值别的线程看不见

审校 2026-09-26 · 素材来源:L04-volatile与CAS与Java内存模型(底稿改写)
📑 本篇章节导航 (共11节,点击直达)
问题根源:每个线程都有自己的小抄volatile:一改动就刷新公告栏但 volatile 管不了原子性happens-before:判断可见性的交通规则final 也有可见性红利两个实验对照着跑volatile 的三类正当用法DCL 的两个平替踩坑清单面试怎么问一句话总结

一个线程把标志位改成 true 了,另一个线程死活读到的还是 false,循环退不出来。代码逻辑没错,错在你没理解 JMM(Java Memory Model,Java 内存模型)——多线程下「谁的修改谁能看见」的规则说明书。

问题根源:每个线程都有自己的小抄

CPU 比内存快几百倍,于是每个 CPU 核心都带缓存(工作内存的物理原型)。JMM 把这套现实抽象成一张图:


线程A ──读写──> 工作内存A ──同步──> 主内存 <──同步── 工作内存B ──读写── 线程B

线程 A 改了变量,可能只改在自己小抄上;线程 B 读的时候看的是自己那份旧小抄。这就是可见性问题。除此之外还有有序性问题:编译器和 CPU 为了快会指令重排(调换执行顺序),单线程看不出来,多线程下会翻车。

JMM 围绕三个特性给方案:

特性意思谁来保证
可见性改动立刻广播volatile、synchronized、final
有序性不许乱序越界volatile、happens-before
原子性操作不可拆synchronized、Atomic 类

volatile:一改动就刷新公告栏

volatile(易变关键字)修饰变量后,JVM 承诺两条:

1. 可见性:写它 → 立刻刷回主内存,并让其他 CPU 里它的缓存副本作废;读它 → 强制去主内存拿最新版

2. 有序性:围绕这个变量的读写,插上内存屏障(一条不许重排跨越的栅栏),屏障外的代码不能乱序越过来

最小验证实验——去掉 volatile 你等一万年也退不出循环:


static volatile boolean running = true; // 去掉 volatile 试试

public static void main(String[] args) throws Exception {
    new Thread(() -> {
        while (running) { }   // 空转,读不到 false 就出不来
    }).start();
    Thread.sleep(1000);
    running = false;          // 主线程改成 false
}

但 volatile 管不了原子性

count++ 看着一步,实际三步:读值、加一、写回。两个线程同时读到 5,各自加一写回 6——两次加法丢了一次。volatile 只保证每次「读」「写」单独是新鲜的,管不了三步之间被人插队。计数器要么 synchronized,要么 AtomicInteger(下节的 CAS)。

happens-before:判断可见性的交通规则

happens-before(先行发生)是 JMM 的裁判规则:A happens-before B,A 的结果就对 B 可见。常用五条:

1. 程序顺序:同一线程里,前面的代码 happens-before 后面的

2. volatile:对它的写 happens-before 后续对它的读

3. 锁:解锁 happens-before 后续加锁

4. 传递性:A→B、B→C,则 A→C

5. 线程 start/join:start 前的赋值对新线程可见;join 返回后,线程里的修改对等待者可见

用它分析经典的双检锁单例(DCL):


class Singleton {
    private static volatile Singleton instance; // volatile 不能省!

    static Singleton get() {
        if (instance == null)                       // ① 没锁快速判断
            synchronized (Singleton.class) {
                if (instance == null)
                    instance = new Singleton();     // ② 关键行
            }
        return instance;
    }
}

new Singleton() 内部分三步:分配内存 → 初始化 → 引用指向内存。后两步没依赖可能被重排成「先指向、后初始化」。线程 A 执行到「已指向、没初始化」,线程 B 在 ① 一看非 null,拿着半成品就跑了。volatile 的屏障禁止这个重排——这就是「DCL 为什么要 volatile」的标准答案。

final 也有可见性红利

不用锁不用 volatile,final 字段自带保证:构造方法里对 final 字段的赋值, happens-before 于构造方法结束后别人拿到这个对象的引用——所以「不可变对象天生线程安全」。配合上「对象发布前不 this 逃逸」,只读共享数据首选不可变对象(String、record、集合包一层 List.of()),比到处加锁干净得多。

两个实验对照着跑

实验一(可见性)已经在「最小验证实验」里:去掉 volatile,循环退不出。

实验二(原子性)再补一刀:


static volatile int count = 0;
// 100 个线程各加 1000 次
for (int i = 0; i < 100; i++) {
    new Thread(() -> {
        for (int j = 0; j < 1000; j++) count++;
    }).start();
}
// 等全部结束,打印 count:几乎必然 < 100000
// 换成 AtomicInteger + incrementAndGet,结果稳定 100000

两个实验一起记住:volatile 管「看不看得见」,Atomic 管「改得对不对」。工程口诀:状态开关用 volatile,计数累加用 Atomic,多步复合上锁。

volatile 的三类正当用法

什么时候该用?三个模板覆盖九成场景:


// ① 状态开关:一写多读,改了必须立刻可见
private volatile boolean shutdown = false;

// ② 双检锁单例:防 new 的三步重排(见上文 DCL)
private static volatile Singleton instance;

// ③ 一次性发布:配置对象整体换新
private volatile AppConfig config;

第三类多说一句:config 每次整个替换成新对象,读侧要么旧完整版、要么新完整版,不会读到改一半的。前提是 AppConfig 不可变——volatile 只保「引用」的可见和有序,保不了对象内部字段。

反面清单同样重要:count++ 不行(复合非原子);先 check 后改不行;多个 volatile 变量之间要维持一致也不行。典型错案:用两个 volatile 存「价格和库存」,写侧分两行赋值,读侧可能读到新价旧量——要么合并成一个不可变对象再 volatile,要么上锁。口诀一句:一次写入多次读,用 volatile;读了还要基于它改,上 Atomic 或锁。

顺带看 JMM 的底层动作:变量在主内存和工作内存之间搬运,规范定义了 read、load、use、assign、store、write 等八种原子操作。名字不用背,抓本质——麻烦出在搬运时机不受控,volatile 就是把时机钉死:写完立刻刷回,读前强制重载。

DCL 的两个平替

手写双检锁容易错,Java 备好了免错的写法:

结论:新代码优先这两个;确实要手写 DCL 的场合(比如实例依赖运行期参数),写错比不写还糟,逐行对照上文检查。

踩坑清单

面试怎么问

一句话总结

每个线程有自己的小抄,volatile 强制「一改就刷公告栏、一读就重抄」;它保可见和有序,不保原子——计数请用 Atomic。