一个线程把标志位改成 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(易变关键字)修饰变量后,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
}
count++ 看着一步,实际三步:读值、加一、写回。两个线程同时读到 5,各自加一写回 6——两次加法丢了一次。volatile 只保证每次「读」「写」单独是新鲜的,管不了三步之间被人插队。计数器要么 synchronized,要么 AtomicInteger(下节的 CAS)。
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」的标准答案。
不用锁不用 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,多步复合上锁。
什么时候该用?三个模板覆盖九成场景:
// ① 状态开关:一写多读,改了必须立刻可见
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 就是把时机钉死:写完立刻刷回,读前强制重载。
手写双检锁容易错,Java 备好了免错的写法:
结论:新代码优先这两个;确实要手写 DCL 的场合(比如实例依赖运行期参数),写错比不写还糟,逐行对照上文检查。
@Contended 或填充隔开每个线程有自己的小抄,volatile 强制「一改就刷公告栏、一读就重抄」;它保可见和有序,不保原子——计数请用 Atomic。