Skip to content

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++。

  • 分层要点:

    1. 先定位“是什么”:JMM 定义在 JLS 第 17 章(17.4 内存模型、17.5 final 字段、17.7 long/double 原子性),是一套允许什么、禁止什么的语义规范,不是硬件结构,也不是 JVM 运行时数据区。教科书里的“主内存 / 工作内存”只是帮助理解的抽象模型,真实硬件是寄存器 + store buffer + 多级缓存 + 一致性协议。和 2.3-1 的堆/栈/Metaspace 要分清:后者讲对象放哪,JMM 讲多线程之间什么时候能看到对方的写。
    2. 为什么必须有 JMM:多核 CPU 每个核有自己的寄存器和缓存,写操作先进 store buffer 再异步刷缓存,读可能命中本地缓存;为了让流水线不断,CPU 会乱序执行,编译器/JIT 还会做指令重排、公共子表达式消除、循环内读提升。若 Java 直接暴露硬件差异,同一份并发代码在 x86 和 ARM 上行为不同。JMM 用 happens-before 划出“程序能看到什么”的边界,只约束到正确性,不承诺具体实现(屏障、缓存行都是实现层)。
    3. 原子性、可见性、有序性,三者不能互替:原子性指一个操作不可分割——基本类型(除 long/double 非 volatile 外)读写原子、引用赋值原子,i++、check-then-act 不是;可见性指一个线程的写何时对另一个线程可见——靠 volatile、synchronized、final、并发容器、CAS 建立;有序性指重排边界——靠 HB 规则和屏障。volatile 给了可见性和有序性,不给复合操作的原子性;synchronized 三者都给,但要阻塞;CAS 给单变量原子性 + 可见性。
    4. 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 保证)。
    5. volatile 的准确语义与实现:volatile 写 = 普通写 + StoreStore 前置屏障 + StoreLoad 后置屏障;volatile 读 = 普通读 + LoadLoad + LoadStore 后置屏障(JSR-133 Cookbook)。语义上保证:写立即对其他线程可见、禁止 volatile 读写与周围普通读写重排、volatile long/double 读写原子、volatile 引用赋值原子。x86 是 TSO 模型,只有 StoreLoad 需要真实指令(写用 lock 前缀,读不额外插屏障);ARM/POWER 更弱,四类屏障都可能落地。注意:volatile int[] 只让数组引用 volatile,元素读写仍是普通访问。
    6. 其他建立 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)。
    7. 安全发布是 JMM 的落地点:五种安全发布——静态初始化器里创建、放进 volatile/AtomicReference、放进正确构造对象的 final 字段、由锁保护、放进并发容器(ConcurrentHashMap、BlockingQueue 等)。DCL 单例必须给实例字段加 volatile,否则“分配 → 赋值 → 初始化”的重排会让其他线程看到非 null 但字段未初始化的对象;静态内部类 holder 利用的正是类初始化 HB。this 在构造期间逃逸(注册监听器、启动线程、调用可覆写方法)会破坏 final 的保证。
    8. 边界与取舍:屏障有成本,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 看到 1
text
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 的写建立 HB
text
安全发布与 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 后续 locksynchronized 临界区交接
volatilevolatile 写 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 ishvolatile 读后
StoreStore前写 vs 后写空操作dmb ishvolatile 写前、final 写前
LoadStore前读 vs 后写空操作dmb ishvolatile 读后、monitor enter
StoreLoad前写 vs 后读lock 前缀 / mfencedmb ishvolatile 写后、monitor exit,通常最贵

屏障本身不是 Java 语言概念:JLS 只规定 happens-before,屏障是 HotSpot/JIT 实现 HB 的手段。面试时先讲 HB,再讲屏障,顺序不能反。

  • volatile / synchronized / final / CAS 对比:
维度plainvolatilesynchronizedfinalCAS / AtomicXxx
单次读写原子基本类型是,long/double 否是(含 long/double)是构造后只读是
复合操作原子否否是(临界区内)不适用单变量是
可见性无保证有有(unlock→lock)正确构造后有有
有序性可任意重排读写前后限制重排临界区内外限制freeze 语义全屏障语义
阻塞否否是否否(失败可重试)
重入——是——
典型用途线程内局部状态标志、发布引用、DCL临界区、复合操作不可变对象计数器、无锁结构
  • 安全发布方式表:
发布方式依赖的 HB注意
静态初始化器(static final)类初始化 HB 后续使用最简单可靠,适合无参单例
volatile / AtomicReferencevolatile 写 HB 后续读对象内部字段仍需 final 或不可变
正确构造对象的 final 字段final freezethis 不能逃逸;只保证引用,不保证引用对象内部
锁保护(synchronized)unlock HB 后续 lock读也要在同一把锁内
并发容器(CHM、BlockingQueue 等)容器内部同步不要先存普通 HashMap 再“改成”并发读
  • 常见反模式与修复表:
场景错误写法后果正确写法
延迟初始化单例无 volatile 的 DCL看到非 null 未初始化对象private static volatile + DCL,或静态内部类 holder
停止标志boolean running 非 volatileJIT 把读提升出循环,线程不退出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+):
模式方法原子性有序性等价语境
plaingetPlain/setPlain基本类型/引用是,long/double 可撕裂无普通字段访问
opaquegetOpaque/setOpaque是(单变量)保证一致性,不保证跨变量顺序类似 AtomicLong.get 但更弱
acquire/releasegetAcquire/setRelease是单向:release 写 → acquire 读发布/消费
volatilegetVolatile/setVolatile是完整内存语义等价 volatile
compareAndSet 等compareAndSet/compareAndExchange/getAndAdd是volatile 级等价原子类
  • 深挖点(面试官常追的 6 个):

    1. 硬件到底重排了什么:CPU 的 store buffer 让写不能立刻被其他核看到,invalidate queue 让失效消息被延迟处理,编译器/JIT 会做指令重排和循环内读提升。x86 是 TSO,只允许 Store→Load 重排;ARM/POWER 更弱,四类重排都可能。JMM 不去描述这些硬件细节,只用 HB 告诉你“哪些重排允许被观察到”。
    2. happens-before 的精确定义:它是偏序关系,不是时间顺序;A HB B 说明 A 的写对 B 可见、且 A 在 B 之前被观察。HB 有传递性,但不意味着 B 一定在 A 之后执行。数据竞争的定义是“两条访问同一变量、至少一个写、且无 HB”;JMM 只对有数据竞争的程序放宽(允许看到任意旧值),无数据竞争的程序满足顺序一致性。这是回答“为什么加了 volatile 就对了”的理论根。
    3. volatile 的屏障实现与边界:写前 StoreStore、写后 StoreLoad;读后 LoadLoad、LoadStore;x86 上只有 StoreLoad 真实存在(lock 前缀),所以 x86 的 volatile 写贵、读便宜。volatile 不保证 i++ 原子、不保证 check-then-act 原子、不保证 volatile int[] 的元素可见;volatile 也不等于“刷新所有缓存”,它是通过 HB 约束可见性。
    4. synchronized / final / CAS 的 HB:monitorenter 是 acquire、monitorexit 是 release,unlock HB 后续对同一监视器的 lock;final 字段在构造器结束时“冻结”,前提是 this 未逃逸,且只保证 final 引用/基本值本身,不保证它指向对象的内部状态;CAS 通过内部的 volatile 字段 + 原子指令实现,AtomicInteger.get/set 是 volatile 读写,lazySet 是 release 语义(允许与后续操作重排,但保证之前写可见)。
    5. 安全发布与对象初始化:发布 = 让其他线程拿到引用并能安全使用。DCL 的问题不是“没加锁”,而是“引用的写和对象初始化的写被重排”;静态内部类 holder 靠类初始化锁;不可变对象(所有字段 final、构造后不改)天然可安全发布;this 逃逸(构造中注册回调、启动线程、调用可覆写方法)会让 final 保证失效,常见于 Spring 初始化回调、事件监听器注册。
    6. 伪共享与 JMM 的边界:伪共享是两个线程改同一缓存行里的不同变量,导致缓存行反复失效,属于性能问题;JMM 管的是正确性,不解决伪共享。@Contended 在 JDK 8 引入(JEP 142),默认只对 JDK 内部类生效;用户类要用得开 --add-exports 和 -XX:-RestrictContended,或者手工 padding。另一个常见混淆:LongAdder 的分段计数解决的是竞争,不是伪共享,但分段后确实更容易落在不同缓存行。
  • 追问链:

    1. 什么是 JMM? → Java 内存模型,JLS 第 17 章定义的并发语义规范,规定多线程下读写何时可见、哪些重排允许。
    2. JMM 和 JVM 运行时数据区有什么区别? → JMM 是语义规范(可见性/有序性/原子性);堆、栈、Metaspace 是内存布局,讲对象放哪里。
    3. “工作内存”是真实存在的内存吗? → 不是,是帮助理解的抽象;真实硬件是寄存器、store buffer、多级缓存。
    4. 为什么需要 JMM? → 多核缓存、store buffer、乱序执行、编译器重排会让同一段代码在不同平台行为不同,需要统一语义。
    5. 硬件和编译器有哪些重排? → 编译器指令重排、JIT 优化、指令级并行、CPU 乱序执行、store buffer/失效队列导致的延迟可见。
    6. 什么是 as-if-serial? → 单线程内无论怎么重排,结果必须和顺序执行一致;它只保护单线程,跨线程靠 HB。
    7. JMM 保证哪三件事? → 原子性、可见性、有序性。
    8. 原子性怎么保证? → 基本类型读写/引用赋值天然原子(long/double 例外),复合操作靠 synchronized、CAS、原子类、锁。
    9. 可见性怎么保证? → volatile、synchronized、final、CAS/原子类、并发容器,本质都是建立 happens-before。
    10. 有序性怎么保证? → HB 规则 + 内存屏障,禁止特定方向的重排。
    11. 什么是 happens-before? → 偏序关系:A HB B 表示 A 的结果对 B 可见,且 A 在 B 之前被观察到。
    12. HB 是时间先后吗? → 不是;时间上重叠也可能有 HB,时间上在前也可能没有。
    13. HB 有哪些规则? → 程序顺序、监视器锁、volatile、start、join/终止、中断、终结器、传递性。
    14. 传递性怎么用? → x=1 程序顺序到 volatile 写,volatile 写/读建立关系,再程序顺序到读 x,推出 x=1 HB 读 x。
    15. 什么是数据竞争? → 两条访问同一非 volatile/非 final 变量、至少一个写、且没有 HB 关系。
    16. 有数据竞争会怎样? → JMM 允许看到旧值、允许重排结果,程序行为不可预期。
    17. 什么是 DRF-SC? → 无数据竞争(正确同步)的程序,在 JMM 下表现为顺序一致。
    18. volatile 保证原子性吗? → 单次读/写是原子的(含 volatile long/double),i++、check-then-act 不是。
    19. 为什么 i++ 不原子? → 读-改-写三步,volatile 只约束每一步的可见性和顺序,不把三步合成一步。
    20. volatile 的内存屏障怎么插? → 写前 StoreStore、写后 StoreLoad;读后 LoadLoad、LoadStore。
    21. 四类屏障各防什么? → LoadLoad 防读读、StoreStore 防写写、LoadStore 防读写、StoreLoad 防写读。
    22. 哪类屏障最贵? → StoreLoad,通常要刷新 store buffer / 内存序;x86 上只有它是真实指令。
    23. x86 上 volatile 读有开销吗? → 基本没有额外屏障指令(TSO 已保证读读/读写顺序),写才有 lock 前缀。
    24. volatile 数组的元素是 volatile 吗? → 不是,只有数组引用是;元素要用 AtomicIntegerArray 或 VarHandle。
    25. volatile 能防止所有重排吗? → 只限制 volatile 读写与周围普通读写之间的特定方向重排,不限制无关变量之间的重排。
    26. DCL 单例为什么要 volatile? → 防止“分配 → 引用赋值 → 初始化”重排,避免其他线程看到非 null 未初始化对象。
    27. 不加 volatile 的 DCL 会怎样? → 绝大多数时候正常,高并发/特定 JIT 下偶发 NPE 或字段为 0,极难复现。
    28. 静态内部类单例为什么安全? → 类初始化由 JVM 加锁,<clinit> 完成 HB 后续对该类的使用。
    29. final 字段为什么能安全发布? → 构造器结束时 freeze,正确构造且 this 未逃逸时,看到引用就能看到 final 字段的初始化值。
    30. this 逃逸会怎样? → final 保证失效,其他线程可能看到未初始化的 final 字段。
    31. final 引用指向的对象内容安全吗? → 不安全,final 只保证引用本身;对象内部可变字段仍需同步或本身不可变。
    32. synchronized 的 HB 怎么建立? → 同一监视器 unlock HB 后续 lock;临界区内写对下一进入者可见。
    33. CAS 有 HB 吗? → 有,compareAndSet 具备 volatile 读写语义,成功写对后续读可见。
    34. lazySet 是什么? → release 语义的写:保证之前的写可见,但允许与后续操作重排;用于“最后发布”场景。
    35. VarHandle 的访问模式有哪些? → plain、opaque、acquire/release、volatile,外加 CAS/getAndAdd 等原子操作。
    36. 原子类和 volatile 的区别? → 原子类在 volatile 之上提供 CAS/自增等复合原子操作;volatile 只有单次读写保证。
    37. start/join 的 HB 是什么? → start() HB 新线程内动作;线程内所有动作 HB 其他线程从 join() 返回。
    38. interrupt 有 HB 吗? → 有,interrupt() HB 被中断线程检测到中断。
    39. 类初始化有 HB 吗? → 有,<clinit> 完成 HB 后续对该类的使用。
    40. 并发容器靠什么保证可见性? → 内部用 volatile、CAS、锁建立 HB,例如 CHM 的节点 val/next 是 volatile。
    41. ThreadLocal 能跨线程传递吗? → 不能,它是线程私有;InheritableThreadLocal 只在创建子线程时复制,之后不共享。
    42. 安全发布有哪些方式? → 静态初始化、volatile/AtomicReference、final 字段(正确构造)、锁保护、并发容器。
    43. 伪共享和 JMM 有关吗? → 没有直接关系;伪共享是缓存行性能问题,JMM 管正确性。
    44. 怎么解决伪共享? → 填充缓存行、@Contended(需 -XX:-RestrictContended)、把热点变量分散到不同对象/行。
    45. 内存屏障有性能开销吗? → 有,StoreLoad 最贵;但多数业务瓶颈不在屏障,先测再优化。
    46. 线上怎么排查可见性问题? → 先审查共享变量有没有 HB:非 volatile 标志、DCL、普通 HashMap 并发读写、this 逃逸;再用压测/JFR 辅助。可见性问题不能靠日志或 sleep 验证,核心是代码审查。
    47. 面试怎么总结? → 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 保证正确性,性能必须实测,不要提前加屏障。
  • 易错点:

    • 认为 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 逃逸 → 反模式与生产案例 → 伪共享与性能取舍 → 常见误区收尾。