Appearance
2.4-1 JMM、happens-before、内存屏障、指令重排
所属:02 Java 运行时 / 2.4 并发 分级:A 状态:◐ 初稿 关联:2.2-2、2.3-8、2.4-2、2.4-3、2.4-5、2.4-8、2.4-15
题型:原理 / 源码
一句话结论:JMM 是 Java 的并发内存语义规范,不是堆/栈的物理划分;它用 happens-before 定义“一个操作的结果何时对另一个线程可见”,靠 volatile、synchronized、final、CAS、类初始化建立 HB,靠内存屏障约束 JIT 和 CPU 的重排,最终同时兜住原子性、可见性、有序性。没有 HB 的跨线程读写就是数据竞争;volatile 只保证单次读写的可见与有序,救不了
i++。分层要点:
- 先定位“是什么”:JMM 定义在 JLS 第 17 章(17.4 内存模型、17.5 final 字段、17.7 long/double 原子性),是一套允许什么、禁止什么的语义规范,不是硬件结构,也不是 JVM 运行时数据区。教科书里的“主内存 / 工作内存”只是帮助理解的抽象模型,真实硬件是寄存器 + store buffer + 多级缓存 + 一致性协议。和 2.3-1 的堆/栈/Metaspace 要分清:后者讲对象放哪,JMM 讲多线程之间什么时候能看到对方的写。
- 为什么必须有 JMM:多核 CPU 每个核有自己的寄存器和缓存,写操作先进 store buffer 再异步刷缓存,读可能命中本地缓存;为了让流水线不断,CPU 会乱序执行,编译器/JIT 还会做指令重排、公共子表达式消除、循环内读提升。若 Java 直接暴露硬件差异,同一份并发代码在 x86 和 ARM 上行为不同。JMM 用 happens-before 划出“程序能看到什么”的边界,只约束到正确性,不承诺具体实现(屏障、缓存行都是实现层)。
- 原子性、可见性、有序性,三者不能互替:原子性指一个操作不可分割——基本类型(除 long/double 非 volatile 外)读写原子、引用赋值原子,
i++、check-then-act不是;可见性指一个线程的写何时对另一个线程可见——靠 volatile、synchronized、final、并发容器、CAS 建立;有序性指重排边界——靠 HB 规则和屏障。volatile给了可见性和有序性,不给复合操作的原子性;synchronized三者都给,但要阻塞;CAS 给单变量原子性 + 可见性。 - happens-before 是偏序,不是时间先后:A HB B 的含义是“A 的结果对 B 可见,且 A 在 B 之前被观察到”;两个操作在时间上重叠也可能有 HB,时间上在前也可能没有 HB。核心规则:程序顺序、监视器锁(unlock HB 后续对同一锁的 lock)、volatile(写 HB 后续读)、线程启动(
start()HB 新线程内动作)、线程终止(线程内所有动作 HB 其他线程从join()返回)、中断(interrupt()HB 被中断线程检测到中断)、终结器、传递性。两条访问同一非 volatile/非 final 变量、至少一个写、且没有 HB 关系,就叫数据竞争;正确同步(无数据竞争)的程序在 JMM 下表现为顺序一致(DRF-SC 保证)。 - volatile 的准确语义与实现:volatile 写 = 普通写 + StoreStore 前置屏障 + StoreLoad 后置屏障;volatile 读 = 普通读 + LoadLoad + LoadStore 后置屏障(JSR-133 Cookbook)。语义上保证:写立即对其他线程可见、禁止 volatile 读写与周围普通读写重排、volatile long/double 读写原子、
volatile引用赋值原子。x86 是 TSO 模型,只有 StoreLoad 需要真实指令(写用lock前缀,读不额外插屏障);ARM/POWER 更弱,四类屏障都可能落地。注意:volatile int[]只让数组引用 volatile,元素读写仍是普通访问。 - 其他建立 HB 的来源,别只盯着 volatile:
synchronized的 monitorenter/monitorexit 带 acquire/release 语义,同一监视器上的 unlock HB 后续 lock(2.4-2);final字段有冻结(freeze)语义——正确构造且this未逃逸时,其他线程看到引用就能看到 final 字段的初始化值(JLS 17.5),但只保证引用本身,不保证引用对象的内部状态;CAS/AtomicXxx内部字段是 volatile,compareAndSet具备 volatile 读写语义(2.4-5);类初始化(<clinit>)HB 后续对该类的任何使用;JDK 9 的VarHandle把内存语义拆成 plain/opaque/acquire/release/volatile 五档(JEP 193)。 - 安全发布是 JMM 的落地点:五种安全发布——静态初始化器里创建、放进 volatile/AtomicReference、放进正确构造对象的 final 字段、由锁保护、放进并发容器(
ConcurrentHashMap、BlockingQueue等)。DCL 单例必须给实例字段加 volatile,否则“分配 → 赋值 → 初始化”的重排会让其他线程看到非 null 但字段未初始化的对象;静态内部类 holder 利用的正是类初始化 HB。this在构造期间逃逸(注册监听器、启动线程、调用可覆写方法)会破坏 final 的保证。 - 边界与取舍:屏障有成本,StoreLoad 通常最贵(一次内存序刷新);x86 上只有 StoreLoad 真实存在,所以“volatile 很贵”在 x86 主要指写。伪共享不是 JMM 问题,是缓存行层面的性能问题,用 padding 或
@Contended解决(后者是 JDK 内部注解,用户类需要--add-exports+-XX:-RestrictContended,生产更常用手工填充)。JMM 保证正确性,不保证快:要不要 volatile 先问“有没有数据竞争”,再问“性能是否真的瓶颈”,不要用“加 volatile 更快”这种反因果的说法。
图/流程:
text
硬件侧的可见性问题:
Core 0 Core 1
┌─────────────┐ ┌─────────────┐
│ registers │ │ registers │
│ store buffer│ ── 异步刷出 ──┐ │store buffer │
│ L1/L2 cache │ ▼ │ L1/L2 cache │
└─────────────┘ 共享 L3 / 内存
▲ │ ▲
└──── 失效队列(invalidate queue) ─────┘
结果:Core 0 的写可能停留在 store buffer / 本地缓存,
Core 1 短时间内读不到 —— 这就是“不可见”。
重排来源:编译器优化、JIT 内联/提升、指令级并行、CPU 乱序、store buffer 延迟
约束边界:as-if-serial(单线程语义不变)+ happens-before(跨线程可见性)text
happens-before 传递链(volatile 发布):
Thread A Thread B
───────────────────────────── ─────────────────────────────
x = 1; while (!flag) { } // 自旋
flag = true; // volatile 写 ──► int r = x; // 读 x
───────────────────────────── ─────────────────────────────
x = 1 ──程序顺序──► flag = true
flag = true ──volatile 写/读──► B 读到 flag
B 读到 flag ──程序顺序──► B 读 x
传递性 ⇒ x = 1 happens-before B 读 x ⇒ B 看到 1text
volatile 的屏障插入(JSR-133 Cookbook):
volatile 写: [ StoreStore ] flag = true [ StoreLoad ]
volatile 读: r = flag [ LoadLoad ] [ LoadStore ]
x86(TSO):StoreStore/LoadLoad/LoadStore 均为空操作
只有 StoreLoad 落成 lock 前缀指令(写路径)
ARM/POWER:四类屏障都可能需要 dmb 类指令text
DCL 单例的重排:
instance = new Singleton();
── 实际分三步 ──
1. memory = allocate() // 分配内存
2. ctorInstance(memory) // 初始化对象
3. instance = memory // 引用赋值
允许的重排:1 → 3 → 2
Thread A:1 → 3(instance 已非 null,字段仍是默认值)→ 2
Thread B:if (instance != null) 直接使用
→ 看到“非 null 但未初始化”的对象(字段为 0/null)
加 volatile:禁止 2 与 3 重排,且 B 的读与 A 的写建立 HBtext
安全发布与 this 逃逸:
✗ 构造中把 this 交给别人
class Foo {
int a;
Foo() { a = 42; Global.REG.register(this); } // this 逃逸
}
anotherThread: Global.REG.get().a → 可能读到 0
✓ 正确发布
static final Foo INSTANCE = new Foo(); // 类初始化 HB
volatile Foo ref = new Foo(); // volatile 写/读 HB
final Foo ref; Foo() { ref = ...; } // final 冻结(this 不逃逸)
synchronized { ref = ...; } // 锁保护
ConcurrentHashMap.put(...) // 并发容器内部 HB版本/源码锚点:
- JLS 17.4:JMM、happens-before、volatile 语义;JLS 17.5:final 字段语义;JLS 17.7:非 volatile long/double 可能被拆成两次 32 位访问。
- JSR-133(Java 5 起的现行内存模型,取代旧 JMM 的“主内存/工作内存必须同步”式描述);JSR-133 Cookbook 是屏障插入的权威参考,但它是实现指南,不是 Java 规范。
- JEP 193(JDK 9):
java.lang.invoke.VarHandle、getAcquire/setRelease/getOpaque/setPlain/getVolatile等访问模式;VarHandle.acquireFence()/releaseFence()/fullFence()。 - JEP 142(JDK 8):
@Contended;jdk.internal.vm.annotation.Contended默认只允许 JDK 内部使用,用户类需--add-exports java.base/jdk.internal.vm.annotation=ALL-UNNAMED加-XX:-RestrictContended。 - 关键类/方法:
sun.misc.Unsafe/jdk.internal.misc.Unsafe(loadFence/storeFence/fullFence、putOrderedInt≈lazySet)、java.util.concurrent.atomic.AtomicInteger(内部value为 volatile)、LongAdder/Striped64、java.lang.Thread#start/#join、synchronized的monitorenter/monitorexit、java.lang.Class的初始化锁、ConcurrentHashMap、VarHandle。 - HotSpot 实现层:
OrderAccess提供acquire/release/fence/loadload/storestore/loadstore/storeload原语;C2 在 IR 上用 MemBar 表示屏障;x86 的 StoreLoad 落在lock前缀指令上。
happens-before 规则表:
| 规则 | 含义 | 典型场景 |
|---|---|---|
| 程序顺序 | 同一线程内,前面的操作 HB 后面的操作 | x=1; y=2; |
| 监视器锁 | 对同一监视器的 unlock HB 后续 lock | synchronized 临界区交接 |
| volatile | volatile 写 HB 后续对同一变量的读 | 状态标志、发布引用 |
| 线程启动 | Thread.start() HB 新线程中的所有动作 | 启动前初始化上下文 |
| 线程终止 | 线程内所有动作 HB 其他线程从 join() 返回 / isAlive() 为 false | 汇总子线程结果 |
| 中断 | Thread.interrupt() HB 被中断线程检测到中断 | 中断标志可见 |
| 终结器 | 对象的 finalize() 完成 HB 其他线程感知终结 | 已废弃,仅规范提及 |
| 传递性 | A HB B 且 B HB C ⇒ A HB C | 与 volatile 组合发布对象 |
- 四类内存屏障表:
| 屏障 | 约束的重排 | x86(TSO) | ARM/POWER | 常见插入点 |
|---|---|---|---|---|
| LoadLoad | 前读 vs 后读 | 空操作 | dmb ish | volatile 读后 |
| StoreStore | 前写 vs 后写 | 空操作 | dmb ish | volatile 写前、final 写前 |
| LoadStore | 前读 vs 后写 | 空操作 | dmb ish | volatile 读后、monitor enter |
| StoreLoad | 前写 vs 后读 | lock 前缀 / mfence | dmb ish | volatile 写后、monitor exit,通常最贵 |
屏障本身不是 Java 语言概念:JLS 只规定 happens-before,屏障是 HotSpot/JIT 实现 HB 的手段。面试时先讲 HB,再讲屏障,顺序不能反。
- volatile / synchronized / final / CAS 对比:
| 维度 | plain | volatile | synchronized | final | CAS / AtomicXxx |
|---|---|---|---|---|---|
| 单次读写原子 | 基本类型是,long/double 否 | 是(含 long/double) | 是 | 构造后只读 | 是 |
| 复合操作原子 | 否 | 否 | 是(临界区内) | 不适用 | 单变量是 |
| 可见性 | 无保证 | 有 | 有(unlock→lock) | 正确构造后有 | 有 |
| 有序性 | 可任意重排 | 读写前后限制重排 | 临界区内外限制 | freeze 语义 | 全屏障语义 |
| 阻塞 | 否 | 否 | 是 | 否 | 否(失败可重试) |
| 重入 | — | — | 是 | — | — |
| 典型用途 | 线程内局部 | 状态标志、发布引用、DCL | 临界区、复合操作 | 不可变对象 | 计数器、无锁结构 |
- 安全发布方式表:
| 发布方式 | 依赖的 HB | 注意 |
|---|---|---|
静态初始化器(static final) | 类初始化 HB 后续使用 | 最简单可靠,适合无参单例 |
volatile / AtomicReference | volatile 写 HB 后续读 | 对象内部字段仍需 final 或不可变 |
| 正确构造对象的 final 字段 | final freeze | this 不能逃逸;只保证引用,不保证引用对象内部 |
锁保护(synchronized) | unlock HB 后续 lock | 读也要在同一把锁内 |
| 并发容器(CHM、BlockingQueue 等) | 容器内部同步 | 不要先存普通 HashMap 再“改成”并发读 |
- 常见反模式与修复表:
| 场景 | 错误写法 | 后果 | 正确写法 |
|---|---|---|---|
| 延迟初始化单例 | 无 volatile 的 DCL | 看到非 null 未初始化对象 | private static volatile + DCL,或静态内部类 holder |
| 停止标志 | boolean running 非 volatile | JIT 把读提升出循环,线程不退出 | volatile boolean running |
| 计数 | volatile int count++ | 丢更新,只保证单次读写 | AtomicInteger / LongAdder / 锁 |
| 缓存 Map | 普通 HashMap 并发读写 | JDK 7 扩容成环、JDK 8 数据错乱/丢写 | ConcurrentHashMap |
| volatile 数组 | volatile int[] arr 改元素 | 元素不可见 | AtomicIntegerArray / VarHandle / 整数组替换 |
| 跨线程传上下文 | ThreadLocal 塞给子线程 | 子线程读不到,且无 HB | 显式参数传递、InheritableThreadLocal(仅创建时复制)、ScopedValue |
| 对象池 | 非线程安全池跨线程取还 | 读到半初始化/脏对象 | 池内部加锁或并发容器,发布靠 HB |
| 发布引用 | volatile Foo ref,但 Foo 字段非 final 且构造中赋值 | 仍可能看到半初始化 | 构造完成后再赋值给 ref,字段尽量 final |
- VarHandle 内存访问模式表(JDK 9+):
| 模式 | 方法 | 原子性 | 有序性 | 等价语境 |
|---|---|---|---|---|
| plain | getPlain/setPlain | 基本类型/引用是,long/double 可撕裂 | 无 | 普通字段访问 |
| opaque | getOpaque/setOpaque | 是(单变量) | 保证一致性,不保证跨变量顺序 | 类似 AtomicLong.get 但更弱 |
| acquire/release | getAcquire/setRelease | 是 | 单向:release 写 → acquire 读 | 发布/消费 |
| volatile | getVolatile/setVolatile | 是 | 完整内存语义 | 等价 volatile |
| compareAndSet 等 | compareAndSet/compareAndExchange/getAndAdd | 是 | volatile 级 | 等价原子类 |
深挖点(面试官常追的 6 个):
- 硬件到底重排了什么:CPU 的 store buffer 让写不能立刻被其他核看到,invalidate queue 让失效消息被延迟处理,编译器/JIT 会做指令重排和循环内读提升。x86 是 TSO,只允许 Store→Load 重排;ARM/POWER 更弱,四类重排都可能。JMM 不去描述这些硬件细节,只用 HB 告诉你“哪些重排允许被观察到”。
- happens-before 的精确定义:它是偏序关系,不是时间顺序;
A HB B说明 A 的写对 B 可见、且 A 在 B 之前被观察。HB 有传递性,但不意味着 B 一定在 A 之后执行。数据竞争的定义是“两条访问同一变量、至少一个写、且无 HB”;JMM 只对有数据竞争的程序放宽(允许看到任意旧值),无数据竞争的程序满足顺序一致性。这是回答“为什么加了 volatile 就对了”的理论根。 - volatile 的屏障实现与边界:写前 StoreStore、写后 StoreLoad;读后 LoadLoad、LoadStore;x86 上只有 StoreLoad 真实存在(
lock前缀),所以 x86 的 volatile 写贵、读便宜。volatile 不保证i++原子、不保证check-then-act原子、不保证volatile int[]的元素可见;volatile 也不等于“刷新所有缓存”,它是通过 HB 约束可见性。 - synchronized / final / CAS 的 HB:monitorenter 是 acquire、monitorexit 是 release,unlock HB 后续对同一监视器的 lock;final 字段在构造器结束时“冻结”,前提是
this未逃逸,且只保证 final 引用/基本值本身,不保证它指向对象的内部状态;CAS 通过内部的 volatile 字段 + 原子指令实现,AtomicInteger.get/set是 volatile 读写,lazySet是 release 语义(允许与后续操作重排,但保证之前写可见)。 - 安全发布与对象初始化:发布 = 让其他线程拿到引用并能安全使用。DCL 的问题不是“没加锁”,而是“引用的写和对象初始化的写被重排”;静态内部类 holder 靠类初始化锁;不可变对象(所有字段 final、构造后不改)天然可安全发布;
this逃逸(构造中注册回调、启动线程、调用可覆写方法)会让 final 保证失效,常见于 Spring 初始化回调、事件监听器注册。 - 伪共享与 JMM 的边界:伪共享是两个线程改同一缓存行里的不同变量,导致缓存行反复失效,属于性能问题;JMM 管的是正确性,不解决伪共享。
@Contended在 JDK 8 引入(JEP 142),默认只对 JDK 内部类生效;用户类要用得开--add-exports和-XX:-RestrictContended,或者手工 padding。另一个常见混淆:LongAdder的分段计数解决的是竞争,不是伪共享,但分段后确实更容易落在不同缓存行。
追问链:
- 什么是 JMM? → Java 内存模型,JLS 第 17 章定义的并发语义规范,规定多线程下读写何时可见、哪些重排允许。
- JMM 和 JVM 运行时数据区有什么区别? → JMM 是语义规范(可见性/有序性/原子性);堆、栈、Metaspace 是内存布局,讲对象放哪里。
- “工作内存”是真实存在的内存吗? → 不是,是帮助理解的抽象;真实硬件是寄存器、store buffer、多级缓存。
- 为什么需要 JMM? → 多核缓存、store buffer、乱序执行、编译器重排会让同一段代码在不同平台行为不同,需要统一语义。
- 硬件和编译器有哪些重排? → 编译器指令重排、JIT 优化、指令级并行、CPU 乱序执行、store buffer/失效队列导致的延迟可见。
- 什么是 as-if-serial? → 单线程内无论怎么重排,结果必须和顺序执行一致;它只保护单线程,跨线程靠 HB。
- JMM 保证哪三件事? → 原子性、可见性、有序性。
- 原子性怎么保证? → 基本类型读写/引用赋值天然原子(long/double 例外),复合操作靠 synchronized、CAS、原子类、锁。
- 可见性怎么保证? → volatile、synchronized、final、CAS/原子类、并发容器,本质都是建立 happens-before。
- 有序性怎么保证? → HB 规则 + 内存屏障,禁止特定方向的重排。
- 什么是 happens-before? → 偏序关系:A HB B 表示 A 的结果对 B 可见,且 A 在 B 之前被观察到。
- HB 是时间先后吗? → 不是;时间上重叠也可能有 HB,时间上在前也可能没有。
- HB 有哪些规则? → 程序顺序、监视器锁、volatile、start、join/终止、中断、终结器、传递性。
- 传递性怎么用? →
x=1程序顺序到 volatile 写,volatile 写/读建立关系,再程序顺序到读 x,推出 x=1 HB 读 x。 - 什么是数据竞争? → 两条访问同一非 volatile/非 final 变量、至少一个写、且没有 HB 关系。
- 有数据竞争会怎样? → JMM 允许看到旧值、允许重排结果,程序行为不可预期。
- 什么是 DRF-SC? → 无数据竞争(正确同步)的程序,在 JMM 下表现为顺序一致。
- volatile 保证原子性吗? → 单次读/写是原子的(含 volatile long/double),
i++、check-then-act不是。 - 为什么
i++不原子? → 读-改-写三步,volatile 只约束每一步的可见性和顺序,不把三步合成一步。 - volatile 的内存屏障怎么插? → 写前 StoreStore、写后 StoreLoad;读后 LoadLoad、LoadStore。
- 四类屏障各防什么? → LoadLoad 防读读、StoreStore 防写写、LoadStore 防读写、StoreLoad 防写读。
- 哪类屏障最贵? → StoreLoad,通常要刷新 store buffer / 内存序;x86 上只有它是真实指令。
- x86 上 volatile 读有开销吗? → 基本没有额外屏障指令(TSO 已保证读读/读写顺序),写才有
lock前缀。 - volatile 数组的元素是 volatile 吗? → 不是,只有数组引用是;元素要用
AtomicIntegerArray或VarHandle。 - volatile 能防止所有重排吗? → 只限制 volatile 读写与周围普通读写之间的特定方向重排,不限制无关变量之间的重排。
- DCL 单例为什么要 volatile? → 防止“分配 → 引用赋值 → 初始化”重排,避免其他线程看到非 null 未初始化对象。
- 不加 volatile 的 DCL 会怎样? → 绝大多数时候正常,高并发/特定 JIT 下偶发 NPE 或字段为 0,极难复现。
- 静态内部类单例为什么安全? → 类初始化由 JVM 加锁,
<clinit>完成 HB 后续对该类的使用。 - final 字段为什么能安全发布? → 构造器结束时 freeze,正确构造且
this未逃逸时,看到引用就能看到 final 字段的初始化值。 - this 逃逸会怎样? → final 保证失效,其他线程可能看到未初始化的 final 字段。
- final 引用指向的对象内容安全吗? → 不安全,final 只保证引用本身;对象内部可变字段仍需同步或本身不可变。
- synchronized 的 HB 怎么建立? → 同一监视器 unlock HB 后续 lock;临界区内写对下一进入者可见。
- CAS 有 HB 吗? → 有,
compareAndSet具备 volatile 读写语义,成功写对后续读可见。 - lazySet 是什么? → release 语义的写:保证之前的写可见,但允许与后续操作重排;用于“最后发布”场景。
- VarHandle 的访问模式有哪些? → plain、opaque、acquire/release、volatile,外加 CAS/getAndAdd 等原子操作。
- 原子类和 volatile 的区别? → 原子类在 volatile 之上提供 CAS/自增等复合原子操作;volatile 只有单次读写保证。
- start/join 的 HB 是什么? →
start()HB 新线程内动作;线程内所有动作 HB 其他线程从join()返回。 - interrupt 有 HB 吗? → 有,
interrupt()HB 被中断线程检测到中断。 - 类初始化有 HB 吗? → 有,
<clinit>完成 HB 后续对该类的使用。 - 并发容器靠什么保证可见性? → 内部用 volatile、CAS、锁建立 HB,例如 CHM 的节点
val/next是 volatile。 - ThreadLocal 能跨线程传递吗? → 不能,它是线程私有;
InheritableThreadLocal只在创建子线程时复制,之后不共享。 - 安全发布有哪些方式? → 静态初始化、volatile/AtomicReference、final 字段(正确构造)、锁保护、并发容器。
- 伪共享和 JMM 有关吗? → 没有直接关系;伪共享是缓存行性能问题,JMM 管正确性。
- 怎么解决伪共享? → 填充缓存行、
@Contended(需-XX:-RestrictContended)、把热点变量分散到不同对象/行。 - 内存屏障有性能开销吗? → 有,StoreLoad 最贵;但多数业务瓶颈不在屏障,先测再优化。
- 线上怎么排查可见性问题? → 先审查共享变量有没有 HB:非 volatile 标志、DCL、普通 HashMap 并发读写、
this逃逸;再用压测/JFR 辅助。可见性问题不能靠日志或 sleep 验证,核心是代码审查。 - 面试怎么总结? → JMM 是语义规范 → HB 八条规则 → 屏障是实现手段 → volatile/synchronized/final/CAS 各自建立 HB → 安全发布与 DCL → 伪共享是另一层问题。
生产案例/取舍(示例,替换成你的项目):
- DCL 单例实例字段没加 volatile,大促压测时偶发
NullPointerException或字段为 0;加 volatile 后消失。根因是对象发布重排,不是锁没加。 - 服务优雅停机用普通
boolean running做停止标志,压测时线程偶发不退出;JIT 把循环内读提升到循环外。改volatile boolean后稳定。 - 用
volatile int count做 QPS 计数,高并发下少计;volatile 只保证单次读写,count++仍丢更新。改LongAdder。 - 本地缓存用普通
HashMap,读写并发时 CPU 打满、请求卡死;JDK 7 扩容成环,JDK 8 虽不死循环但数据错乱。改ConcurrentHashMap或Caffeine。 - 构造方法里把
this注册到事件总线/启动线程,其他线程偶尔读到字段还是 0;构造完成后才发布,字段改 final。 - 用
volatile int[]做配置数组,热更新后部分线程仍读旧元素;改成整体替换数组引用,或AtomicIntegerArray。 - 自定义线程池用
ThreadLocal传用户上下文,任务在别的线程执行时上下文丢失;改为显式传参或任务包装时拷贝。 - 高频计数器两个字段相邻,压测吞吐上不去,perf 显示缓存行失效;padding 或
@Contended后提升。 - 给对象引用加 volatile 就以为安全,但对象内部字段在构造后才赋值,其他线程仍看到半初始化;把字段改成 final 或构造完成后再发布。
- 线上问题在加了日志后“消失”,因为
println/日志框架内部有同步;去掉日志又复现。可见性问题不能靠打印验证。 - 用
Thread.sleep(100)等“应该可见了”,在低负载机器上正常、高负载机器上偶发;这是靠时间而不是 HB,必须改成 volatile/锁/并发容器。 - 用
System.currentTimeMillis做超时判断,以为时间过去就可见;时间与内存可见性无关。 - 取舍:volatile 便宜但不能替代锁,只解决可见性和有序性;synchronized 语义最全但阻塞、影响吞吐;CAS/原子类适合单变量高频更新,复杂临界区仍要锁;final + 不可变对象是成本最低的安全发布;JMM 保证正确性,性能必须实测,不要提前加屏障。
- DCL 单例实例字段没加 volatile,大促压测时偶发
易错点:
- 认为 JMM 就是堆/栈/Metaspace 的内存划分,实际它是并发语义规范。
- 认为“工作内存”是真实的一块内存,实际只是抽象模型。
- 认为 happens-before 就是“先发生”,实际它是可见性和顺序的偏序,不是时间顺序。
- 认为时间上先执行的操作一定有 HB,实际没有同步就没有。
- 认为 volatile 能保证
i++/check-then-act原子,实际只保证单次读写。 - 认为 volatile 能替代锁,实际复合操作仍要锁或 CAS。
- 认为
volatile int[]的元素也可见,实际只有引用 volatile。 - 认为非 volatile 的 long/double 一定原子,实际规范允许拆成两次 32 位访问。
- 认为 synchronized 只保证互斥、不保证可见性,实际 unlock HB 后续 lock。
- 认为 final 字段在任何情况下都能安全发布,实际
this逃逸会破坏保证。 - 认为 final 引用指向的对象内容也安全,实际只保证引用本身。
- 认为 DCL 不加 volatile 也没事,实际存在重排窗口,问题偶发且难查。
- 认为静态内部类单例只是“语法糖”,实际依赖类初始化 HB。
- 认为 CAS 没有内存语义,实际具备 volatile 读写语义。
- 认为
lazySet和普通写一样,实际是 release 语义,保证之前的写可见。 - 认为 ThreadLocal 能跨线程传值,实际线程私有,
InheritableThreadLocal也只在创建时复制。 - 认为
ConcurrentHashMap只是“线程安全 HashMap”,忽略它内部靠 volatile/CAS 建立 HB。 - 认为内存屏障是 Java 语言规范里的概念,实际 JLS 只规定 HB,屏障是 JVM 实现手段。
- 认为 x86 上四类屏障都有指令,实际只有 StoreLoad 落地。
- 认为
volatile写一定比普通写慢很多,实际在 x86 上是一次lock前缀,读几乎免费。 - 认为加了 volatile 就“刷新所有缓存”,实际是通过 HB 约束可见性,不是全量刷缓存。
- 认为伪共享是 JMM 问题,实际是缓存行层面的性能问题。
- 认为
@Contended在任何类上都能直接用,实际默认只对 JDK 内部生效。 - 认为
Thread.sleep能保证可见性,实际时间流逝不建立 HB。 - 认为加日志后问题消失说明没问题,实际日志内部有同步副作用。
- 认为对象构造完就自动安全发布,实际发布方式不对仍会看到半初始化。
- 认为
volatile引用赋值和对象内部字段更新是原子的,实际只保护引用本身。 - 认为 JMM 只跟 volatile 有关,实际 synchronized、final、CAS、类初始化、并发容器都建立 HB。
- 认为 JMM 能保证性能,实际它只保证正确性,性能要靠测量和取舍。
30 秒口述稿:
JMM 是 Java 的并发内存语义规范,不是堆栈划分。硬件有寄存器、store buffer、多级缓存和乱序执行,JMM 用 happens-before 定义跨线程可见性,用 volatile、synchronized、final、CAS、类初始化建立 HB,用内存屏障约束重排。HB 不等于时间先后,没有 HB 的跨线程读写就是数据竞争。volatile 保证单次读写可见、有序,但不保证
i++原子;synchronized 的 unlock HB 后续 lock;final 有冻结语义,但this不能逃逸。DCL 要 volatile,停止标志要 volatile,计数用原子类或锁。伪共享是缓存行问题,不是 JMM 问题。
- 3 分钟展开顺序:结论(JMM 是语义规范)→ 硬件根因(缓存/store buffer/重排)→ 原子性/可见性/有序性三条线 → happens-before 八条规则与传递性 → 四类屏障与 x86/ARM 差异 → volatile 的语义与边界 → synchronized/final/CAS/类初始化的 HB → 安全发布与 DCL、this 逃逸 → 反模式与生产案例 → 伪共享与性能取舍 → 常见误区收尾。