知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 53 - JMM 与 happens-before 规则 > 导读:本文从"为什么加了 volatile 或锁,线程间莫名其妙的 bug 就消失了"这个现象切入,把 Java 内存模型(JMM)的抽象、重排序的来源、happens-before 的准确含义与 JSR-133 的八条规则讲清,并落到 DCL、可见性失败等真实代码上。适合想看懂 JUC 底层、面试被追问"volatile 为什么能保证可见性"的同学。 ## 一、先建立全局认知 ### Q:写的是 Java 代码,为什么还要关心"内存模型"? A:结论先行——Java 代码最终跑在不同的 CPU 和操作系统上,缓存结构与读写乱序规则并不一致,**JMM 就是 JVM 提供给程序员的一层统一契约**,把底层差异屏蔽掉。 JMM 规定了两件事:一个线程对共享变量的写入在什么条件下能被另一个线程看到;编译器与 CPU 允许对指令做哪些调整。它不针对具体硬件,只回答"允许发生什么、不允许发生什么"。 **主内存与工作内存**是它给出的两层抽象: - **主内存(Main Memory)**:所有共享变量所在之处,可理解为堆里的对象。 - **工作内存(Working Memory)**:每个线程私有的抽象缓存,读写都先经过它,可粗略对应 CPU 缓存加寄存器。 一句话:线程不能直接改主内存,必须"读到工作内存 → 改 → 写回主内存",而**写回时机不确定**——这正是可见性问题的根源。 ### Q:并发三大问题——原子性、可见性、有序性,分别靠什么保证? A:三大问题是并发 bug 的三个来源,Java 用不同手段应对: | 问题 | 一句话定义 | 主要保证手段 | | --- | --- | --- | | 原子性 | 操作要么全做、要么全不做,中间不被插入 | `synchronized` / `Lock` / `CAS` / `AtomicXxx` | | 可见性 | 一个线程的修改,其他线程能及时看到 | `volatile` / `synchronized` / `Lock` / `final` | | 有序性 | 指令按代码预期的顺序被观察 | `volatile` / `synchronized` / `happens-before` | 要提醒的是:**单条 `i = 1` 是原子的,`i++` 不是**(读、加、写三步);`volatile` 只解决可见性与有序性,**不保证复合操作的原子性**。 ## 二、理解核心机制 ### Q:重排序都有哪些来源? A:重排序指实际执行顺序与书写顺序不一致,来源有三: 1. **编译器优化重排序**:编译器/JIT 在不改变单线程语义的前提下调整指令顺序。 2. **指令级并行重排序**:CPU 用流水线、乱序执行让多条指令并行,只要不违反数据依赖。 3. **内存系统重排序**:写缓冲(store buffer)与失效队列让"写"延迟生效,改变其他处理器观察到的读写顺序。 前两者属于"指令顺序"层面,第三种属于"内存可见"层面,往往更隐蔽。 ### Q:既然会重排序,为什么单线程程序"看起来没问题"?什么是 as-if-serial? A:因为有一条底线——**as-if-serial 语义**(无论怎样重排序,单线程程序的执行结果不能被改变)。 它靠**数据依赖**兜底:两个操作存在数据依赖时(如 `a = 1; b = a;`),编译器与 CPU 都不会调整其相对顺序。所以单线程可以"假装"程序按顺序执行,程序员不必为此多写代码。 代价是:**有依赖才有约束,无依赖就能自由重排**。而多线程之间天然缺少依赖,as-if-serial 管不到它们,这正是并发问题的温床。 ### Q:happens-before 到底是什么?它和"时间先后"是一回事吗? A:**不是**,这是最容易被误解的一点。 happens-before(先行发生)的准确含义是:**若操作 A happens-before 操作 B,则 A 的结果对 B 可见,且 A 在排序意义上排在 B 前面**。它描述的是两个操作之间的**可见性与顺序约束**,而不是墙上时钟的绝对时间。 - 真实时间里一先一后的两个操作,**未必**有 happens-before 关系; - 不同线程、物理上几乎同时执行的两个操作,只要满足某条规则,JMM 就必须保证前者结果对后者可见。 所以 happens-before 是**可见性承诺**:只要满足规则,就不必再担心底层怎么乱排。  *图:JMM 的抽象模型与 happens-before 建立可见性保证的路径——主内存、工作内存、volatile 屏障与线程间的传递关系。* ### Q:JSR-133 规定了哪些 happens-before 规则? A:JSR-133(Java 5 引入的 JMM 修订)给出八条: 1. **程序顺序规则**:一个线程内,前面的操作 happens-before 后面的操作。 2. **监视器锁规则**:同一把锁的 `unlock` happens-before 后续的 `lock`。 3. **volatile 变量规则**:volatile 变量的写 happens-before 后续对它的读。 4. **传递性**:A hb B、B hb C,则 A hb C。 5. **start() 规则**:`Thread.start()` happens-before 新线程的第一个操作。 6. **join() 规则**:线程中的所有操作 happens-before 其他线程从 `join()` 成功返回。 7. **线程中断规则**:`interrupt()` 的调用 happens-before 被中断线程检测到中断。 8. **对象终结规则**:对象的构造完成 happens-before 它的 `finalize()` 开始。 日常编码**前四条覆盖绝大多数场景**,后四条是线程生命周期的补充。 ### Q:内存屏障有哪几种?volatile 读写时插入哪些? A:volatile 的可见性靠**内存屏障**(memory barrier,一种约束 CPU 与编译器访存顺序的指令)落地,共四种组合: - **LoadLoad**:禁止后面的读排到前面的读之前; - **StoreStore**:禁止后面的写排到前面的写之前; - **LoadStore**:禁止后面的写排到前面的读之前; - **StoreLoad**:禁止后面的读排到前面的写之前(开销最大,常称"万能屏障")。 volatile 的策略(保守表述,随 JVM 与架构略有差异):**写前**插 StoreStore,**写后**插 StoreLoad;**读后**插 LoadLoad 加 LoadStore。 一句话记忆:**volatile 写像"一堵墙",把之前的都推出去;volatile 读像"一根线",把之后的都拴住**。这也是它能顺带保证"写之前、读之后"相关代码可见的原因。 示意(注释标注屏障位置): ```java // 场景:发布配置对象,用 volatile 保证已初始化的字段对读者可见 public class ConfigHolder { private int timeout; // 普通字段 private volatile boolean ready; // volatile 标志位 public void publish(int t) { timeout = t; // ① 普通写 // ← StoreStore 屏障:保证 ① 在 volatile 写之前刷出 ready = true; // ② volatile 写 // ← StoreLoad 屏障:阻止 ② 与后续操作重排 } public int read() { if (ready) { // ③ volatile 读 // ← LoadLoad / LoadStore 屏障:保证 ③ 之后的读不被提前 return timeout; // ④ 一定能看到 ① 的写入 } return -1; } } ``` 关键点:**StoreStore + LoadLoad/LoadStore** 让"普通字段 + volatile 标志位"成为可靠的**发布/订阅**模式——DCL、状态标记都建立在此之上。 ### Q:final 字段的初始化安全语义是什么? A:`final` 有**初始化安全**保证:**只要构造期间没有把 `this` 引用逸出**(this escape,指构造函数里把自己暴露给其他线程),其他线程通过正确发布的引用读到的 final 字段,一定能看到构造时赋的值,无需额外同步。 这比普通字段强:普通字段构造完成后仍可能因重排序表现为"未初始化"。因此 final 常被用来搭建不可变对象。 ### Q:happens-before 和"实际执行顺序"是什么关系? A:要区分两者:**实际执行顺序**是 CPU 真实执行指令的物理顺序,可因重排序与代码顺序不同;**happens-before 顺序**是 JMM 对可见性给出的逻辑约束,不是物理时间线。 存在 happens-before 关系时,JMM 通过禁止相应重排序(插入屏障)来兑现承诺,物理顺序必须与逻辑顺序一致;不存在该关系时,怎么排都合法。因此 **happens-before 决定"哪些重排序被禁止",而不是记录真实执行顺序**。 ## 三、放进真实场景 ### Q:为什么"加了锁或 volatile,bug 就消失了"? A:因为加锁或 volatile 不是让代码变快,而是**建立了 happens-before 关系**:加 `synchronized` 命中**监视器锁规则**(释放锁 hb 后续加锁),加 `volatile` 命中 **volatile 规则**(写 hb 后续读);再配合**程序顺序规则**与**传递性**,就能推出"我关心的写,对另一个线程的读一定可见"。 也就是说,bug 消失的本质是你无意中给原本没有可见性关系的两段代码补上了这条链。**理解这一点,就能从"试出来的修复"升级为"推理出来的修复"**。 ### Q:双重检查锁(DCL)里,volatile 解决了哪条重排序? A:经典 DCL 用于延迟初始化单例: ```java public class Singleton { private static volatile Singleton instance; // 少了 volatile 就可能出问题 public static Singleton getInstance() { if (instance == null) { // 第一次检查:无锁 synchronized (Singleton.class) { if (instance == null) { // 第二次检查 instance = new Singleton(); // ← 关键 } } } return instance; } } ``` `new Singleton()` **不是原子操作**,可拆成三步:分配内存、初始化对象、把 `instance` 指向该内存。 **没有 volatile** 时,后两步可能被重排序(先执行指针赋值)。另一个线程在第一次检查处会看到**非 null 但尚未初始化完成**的 `instance`,直接用就会读到默认值(0、null)——即"半初始化对象"问题。 `volatile` 通过屏障保证"初始化对象 happens-before 把引用赋给 `instance`",禁止这种重排。(JDK 5 之后 JMM 才正式保证这一点,正是 JSR-133 修订之一。) ### Q:一个真实的可见性失败例子长什么样? A:主线程设置标志位后,子线程可能**一直读不到**、循环不退出: ```java // 反例:stop 不是 volatile,子线程可能永远看不到修改 public class VisibilityBug { private static boolean stop = false; // ← 缺 volatile public static void main(String[] args) throws InterruptedException { Thread worker = new Thread(() -> { while (!stop) { // 子线程可能一直读到 false // 干活 } System.out.println("worker exit"); }); worker.start(); Thread.sleep(100); stop = true; // 主线程改了,子线程未必可见 } } ``` 原因:`stop` 读进工作内存后,JIT 可能把它**提升为寄存器缓存**(等价于"假设它不会变"),循环里读的一直是旧值。修正只需一个关键字: ```java private static volatile boolean stop = false; // 保证写对读可见 ``` 关键点:volatile 让每次读都从主内存(或经屏障的可见副本)获取,打破"缓存旧值"的优化。**这类 bug 不一定复现**——单核、低负载、JIT 未优化时常常"看起来正常",一上量就偶发。 ### Q:能观察到一个"指令交错导致异常输出"的例子吗? A:看这个经典的**重排序示例**。初始 `a = 0, b = 0`: ```java // 线程 1 // 线程 2 r1 = a; r2 = b; // 读 b = 1; a = 1; // 写 ``` 直觉上两组读写总有先后,但**理论上**有 4 种组合:`(0,0)`、`(0,1)`、`(1,0)`、`(1,1)`。 `(1,1)` 意味着线程 1 读到了 a=1、线程 2 读到了 b=1,两条读都发生在对方写之后。若严格按程序顺序执行,这会构成一个循环而**不可能出现**;它能出现,正是 **StoreLoad 级别的重排序**(写缓冲未及时刷出、读从缓存拿到旧值)所允许的。 必须强调:**这不是"一定会出现"的结果**,它依赖具体 CPU 的内存模型、编译器优化与并发压力,多数环境里极难复现。这个例子只用来证明——**代码顺序不等于执行顺序**,因此需要 happens-before 兜底。 ### Q:怎么用 happens-before 自查代码安全性? A:沿 happens-before 链问三个问题: 1. **共享变量有没有被多线程读写?** 只读或只被单线程写,通常不用管。 2. **写和读之间有没有一条链?** 看是否落在 volatile 规则、监视器锁规则、start/join 规则里,或能用传递性串起来。 3. **链的根基牢不牢?** 全靠"代码看起来是先写的"来假设就是隐患;链条成立,则底层怎么重排都不必担心。 结论:**不要凭直觉排序,要凭规则推理**。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:按"为什么 → 是什么 → 怎么用"三段: 1. **为什么**:硬件内存规则不一,JMM 提供统一的可见性与有序性契约,抽象为主内存加工作内存;三大问题是原子性、可见性、有序性。 2. **是什么**:重排序来自编译器、指令级并行、内存缓冲;as-if-serial 保单线程语义;happens-before 是可见性约束而非时间先后,JSR-133 有八条规则。 3. **怎么用**:volatile 靠四种屏障落地;DCL 靠 volatile 禁止"初始化与指针赋值"重排;循环读标志位靠 volatile 修复;最后用 happens-before 链推理安全性。 ### Q:如果追问"volatile 和 synchronized 都保证可见性,怎么选"? A:两者都能建立 happens-before,但定位不同:`volatile` 轻量,只保证单个变量的可见性与有序性,**不保证复合操作原子性**,适合状态标志、一次性安全发布;`synchronized` 加锁范围更大,**同时保证原子性与可见性**,适合多个变量需一起保持一致的临界区。选型看**是否需要原子性**:需要就加锁,否则单变量用 volatile。 --- ## 自测 1. happens-before 说的是"时间上先发生"吗?请解释"两个线程物理上几乎同时执行,却仍有可见性保证"。 2. 重排序的三个来源是什么?as-if-serial 语义为什么管不到多线程? 3. DCL 里如果不加 volatile,`new Singleton()` 可能怎样被重排序?会导致什么后果? 4. volatile 写和读分别插入哪几类内存屏障?为什么它不解决原子性?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入