外观
06 - 并发底层:从 JMM 契约到 HotSpot 实现
以 Java 语言规范(JLS)17 和 HotSpot 17 为基线;volatile 实验兼容 JDK 8,VarHandle 实验要求 JDK 9+,较新锁实现另标条件。HotSpot 是这里讨论的 JVM 实现,不能用它的内部结构代表所有 JVM。
阅读指引
- 本文定位:并发实现分支,把 JMM 语言契约连接到编译器、屏障和 HotSpot 锁实现;不重复业务线程安全与 JUC 使用教程。
- 前置阅读:并发 03 JMM 与 happens-before提供正确性判断;构造和编译背景按需补 02、05。运行时数据区不是 JMM。
- 后续阅读:并发 A 代码测试方法用于检验并发假设,07 JVM 排障用于现场线程与锁证据采集。
- 学习目标:能区分规范保证、HotSpot 实现与硬件观察;实验未出现错误不等于证明正确,某平台指令也不能替代 happens-before 推导。
摘要
x86 上测试没有失败,能否证明普通字段发布安全?volatile 的读写为什么不让 count++ 原子化?线程显示 BLOCKED,能否反推出对象头状态?理解这些问题,需要先用 Java 内存模型判断程序允许出现哪些结果,再看编译器和 CPU 如何实现这些约束。本文按这个顺序展开,并用带超时保护的实验说明发布与复合操作的边界。
1. 现象:测试正常不等于没有数据竞争
设想一个教学场景:工作线程循环读取普通 boolean 停止标志,另一个线程把它改为 true。开发机上线程总能退出,换负载或 JDK 后却可能一直循环。
Java 内存模型(JMM)规定多线程读写允许呈现的行为。如果两个线程访问同一个变量,至少一个在写入,而这些冲突访问之间没有 happens-before 关系,就存在数据竞争。happens-before(先行发生)是推导可见性和顺序约束的关系,并不是按时钟比较谁先执行。
因此,分析停止标志时,应先检查写入与读取之间有没有同步关系。缺少这条关系时,JIT(即时编译器)优化和运行环境都可能影响观察结果,不能仅凭线程不退出就断定“缓存没刷回主存”。测试可以寻找反例,但某次正常退出不能补上程序缺少的保证。
| 层次 | 回答的问题 | 不能代替 |
|---|---|---|
| JMM/JLS | 什么执行结果被允许 | 某台机器上的偶然结果 |
| HotSpot 中间表示(IR)/编译代码 | 如何保持语义、消除或合并屏障 | 全部 JVM 的固定指令模板 |
| CPU 内存序/一致性 | 指令与存储系统提供哪些顺序 | Java 编译器的优化限制 |
| 测试/采样 | 实际观察到什么 | 对所有执行的正确性证明 |
运行时数据区回答“数据放在哪里”,JMM 回答“跨线程读写可以观察到什么”。因此,不能把 JMM 的主内存、工作内存与堆、CPU 缓存一一对应,见 01。缓存一致性描述硬件如何协调缓存中的数据副本;它并不替 Java 程序建立同步关系,也不能约束所有 Java 编译器优化。
2. 原理:先建立发布链,再讨论屏障
基础入口:先区分可见性、原子性与有序性
| 问题 | 通俗含义 | 典型错误 |
|---|---|---|
| 可见性 | 一个线程的写入,另一个线程能按协议观察到 | 普通停止标志没有同步关系,却依赖循环及时退出 |
| 原子性 | 一组操作不会以不允许的中间状态被交错 | 两个线程都读到 count=0,各自写回 1,丢掉一次增量 |
| 有序性 | 必须满足的操作先后约束 | 看到“准备好了”,却没有保证能读到准备的数据 |
volatile int count 可以参与建立可见性和顺序保证,但 count++ 仍是读取、加一、写回三步。两个线程可能读到相同的旧值,再分别写回相同的新值,于是丢掉一次增量。AtomicInteger.incrementAndGet() 提供一个原子的增量操作;如果还要一起修改库存、总价和状态,一个原子计数器并不能保护整个业务不变量,也就是多个字段必须共同满足的业务约束。
发布是把准备好的数据交给另一个线程读取。最基础的协议是:写者先写普通字段 payload,再写同一个 volatile 标志 ready;读者确认 ready 表示发布完成后,再读 payload。这条链需要两部分规则:线程内的程序次序,以及 volatile 写与后续读之间的同步关系。使用锁时,对应的跨线程关系来自同一把锁的释放与后续获取。
2.1 发布保证不是复合操作的原子性
常用规则如下,读实现前可先用它检查同步路径;完整推导和并发 API 的其他保证见 并发 03。
| 规则 | 保证如何连接 | 不提供什么 |
|---|---|---|
| 程序次序 | 同一线程中前面的操作 happens-before 后面的操作 | 不要求机器指令始终照源码顺序执行 |
| Monitor | 同一监视器的释放 happens-before 后续获取 | 两个不同锁之间不自动建立这条边 |
| volatile | 同一 volatile 变量的写 happens-before 后续适用的读 | 不把多步自增或多个字段一起变成原子快照 |
| 线程启动 | start() 前的操作经程序次序连接到新线程执行 | sleep() 和“线程应该已经运行了”不是启动同步边 |
| 线程结束 | 线程中的操作连接到另一线程成功等待其终止的 join() | 限时 join 超时返回不能当作目标线程已终止 |
| 传递性 | A happens-before B、B happens-before C,可以推导 A 到 C | 墙钟上 A 比 C 早,不足以自动建立关系 |
把发布链拆开,就能看出传递性如何起作用:写 payload happens-before 写 ready,写 ready 与适用的后续读建立同步关系,读 ready 又 happens-before 随后的 payload 读取。读到了旧标志、使用了另一个变量,或先读 payload 再检查标志,都不能直接套用这条推导。日志和睡眠也不能替代所需的发布协议。
这条保证针对发布前的写入。它不会把多个字段变成原子快照,也不会把“读 → 计算 → 写”变成单步;发布后的可变数据仍需要自己的同步协议。
final 字段还有特殊的初始化安全性。对象正确构造、构造期间没有不当的 this 逃逸时,构造结束处的 freeze(冻结)语义为 final 字段提供特定保证;this 逃逸指对象尚未构造完,外部代码就已经取得它的引用。这种保证即使在引用通过数据竞争传递时也可能适用,但不保证引用及时可见、普通可变字段安全,或整个对象及其引用的内容都不可变。业务仍应正确发布对象,并定义后续修改协议。
双重检查锁是在锁外先检查实例是否存在,进入锁后再检查一次,以避免重复创建。分析它时,关键是 instance 的发布与读取同步,以及对象构造的边界;不能仅靠把源码中的 new 拆成固定的“三步机器码重排”图解释。构造默认值与 this 逃逸的反例见 02。
3. 实现:编译器屏障不等于固定 CPU 指令
内存屏障可以先理解为“禁止越过某个边界做特定重排的约束”。它不是让所有线程停下来,也不是把整个堆统一复制到 CPU 缓存。编译器必须保留语言要求的效果,生成代码时再利用目标 CPU 提供的指令与内存序完成约束;这就是为什么应先证明 Java 程序正确,再看具体机器指令。
Load 表示读,Store 表示写;LoadLoad、LoadStore、StoreStore、StoreLoad 用前后的操作类型描述重排约束。HotSpot 在中间表示(IR)中表达内存序,也就是内存访问必须满足的顺序要求,再将它转换为目标 CPU 的机器代码。屏障可能被合并,也可能在已有更强约束时省略,因此每次 volatile 访问并不一定生成相同指令,StoreLoad 也不能一概视为某条最昂贵的指令。
| 抽象分类 | 约束的操作方向 | 通俗理解 |
|---|---|---|
| LoadLoad | 边界前的读与边界后的读 | 对这两类读取建立需要的先后约束 |
| LoadStore | 边界前的读与边界后的写 | 限制相应读取和后续写入跨越边界重排 |
| StoreStore | 边界前的写与边界后的写 | 约束先写数据、再写发布状态等顺序 |
| StoreLoad | 边界前的写与边界后的读 | 约束相应写入与后续读取的顺序 |
- x86 与 AArch64(ARM 的 64 位架构)的内存序不同;同一 Java 契约可能对应普通读写指令、带 acquire/release 语义的指令,或额外的 fence(屏障)。
- CAS(比较并交换)在当前值与预期值相同时原子更新。它可以由架构原子指令或独占访问等机制实现;这只能解释一次原子操作,不能证明整个多步业务流程都能视为在某一瞬间完成,即满足线性化要求。
- GC 写屏障维护垃圾回收所需的可达性或记忆集信息,JMM 屏障维护内存序,目的不同。记忆集用于记录回收器需要追踪的引用关系;同一访问路径可能同时包含两类机制,见 04、A。
实际指令需匹配 JVM build、编译层级、方法、CPU、GC 和 flags,再查看生成代码;下文 Java 输出不包含反汇编或 AArch64 证据,不能用于推导具体指令序列。
3.1 VarHandle 的访问模式
VarHandle 是读写某个变量的句柄,调用者可以为访问选择不同的内存语义。release(释放)与 acquire(获取)用于定向约束:写者在发布状态前准备数据,读者观察到相应发布值后读取数据。它们需要通过实际访问的变量和读到的值连接,不能只看方法名就认为两个线程完成了同步。
| 模式 | 适用理解 | 容易误用 |
|---|---|---|
| plain get/set | 普通访问契约 | 以为 get 的循环一定重读并及时退出 |
| opaque | 较弱的有序/一致性约束 | 当作发布整个关联对象的 release/acquire |
| setRelease/getAcquire | 匹配观察发布值时的定向内存序 | 任意两个不同变量的访问自动配对 |
| volatile get/set | 较强的 volatile 顺序契约 | 认为复合自增也原子 |
| compareAndSet 等 | 原子更新;不同变体有不同内存效果 | 所有 weak CAS 都同样内存序且不会虚假失败 |
访问模式由调用的 VarHandle API 决定,不能仅凭字段声明为 volatile 就推断每种模式都具有 volatile 语义。weak CAS 中的“弱”还意味着操作可能虚假失败,即预期值匹配也可能未更新,不能把一次失败直接解释为值被其他线程修改。fence 只约束顺序,不会凭空提供通信变量或改变读到的值;业务代码应优先使用成熟的并发结构。
4. 进阶选读:强制复合操作交错,而非赌丢更新
不运行程序也能先推导反例:线程 A 读到 0,线程 B 也读到 0,A 写回 1,B 再写回 1。两次增量只留下 1,因此 volatile 的可见性不能使复合操作原子化。下面使用同步屏障人为安排这个交错,目的是稳定呈现反例;其中超时、错误传递和线程退出属于实验保护,不是理解 volatile 必须先掌握的 API。
保存为 VolatileIncrementDemo.java,兼容 JDK 8/17。CyclicBarrier 是让参与线程都到达约定位置后再继续的同步工具,与前文限制内存重排的屏障不同。每轮第一次 await() 确保两个线程都读完旧值,再允许写回;第二次确保两者都写完,再进入下一轮。因此,每轮两次写入都写回同一个值,计数只增加一次。这里显式拆开 count++ 的读改写步骤,用人为安排的交错展示边界,不是竞争吞吐基准。
java
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
public final class VolatileIncrementDemo {
private static volatile int count;
public static void main(String[] args) throws Exception {
int rounds = 1000;
CyclicBarrier barrier = new CyclicBarrier(2);
AtomicReference<Throwable> failure = new AtomicReference<>();
Runnable update = () -> {
try {
for (int round = 0; round < rounds; round++) {
int observed = count;
barrier.await(2, java.util.concurrent.TimeUnit.SECONDS);
count = observed + 1;
barrier.await(2, java.util.concurrent.TimeUnit.SECONDS);
}
} catch (Throwable problem) {
failure.compareAndSet(null, problem);
}
};
Thread first = new Thread(update, "volatile-first");
Thread second = new Thread(update, "volatile-second");
first.setDaemon(true);
second.setDaemon(true);
first.start();
second.start();
first.join(10000);
second.join(10000);
if (first.isAlive() || second.isAlive() || failure.get() != null) {
first.interrupt();
second.interrupt();
throw new IllegalStateException("workers did not finish", failure.get());
}
if (count != rounds) {
throw new AssertionError("unexpected volatile result: " + count);
}
AtomicInteger atomic = new AtomicInteger();
Runnable atomicUpdate = () -> {
for (int round = 0; round < rounds; round++) {
atomic.incrementAndGet();
}
};
Thread atomicFirst = new Thread(atomicUpdate);
Thread atomicSecond = new Thread(atomicUpdate);
atomicFirst.setDaemon(true);
atomicSecond.setDaemon(true);
atomicFirst.start();
atomicSecond.start();
atomicFirst.join(10000);
atomicSecond.join(10000);
if (atomicFirst.isAlive() || atomicSecond.isAlive() || atomic.get() != 2 * rounds) {
throw new AssertionError("atomic workers failed");
}
System.out.println("volatile=" + count + " atomic=" + atomic.get());
}
}bash
javac VolatileIncrementDemo.java
java VolatileIncrementDemo预期输出:volatile=1000 atomic=2000。同步屏障增加了顺序保证,但没有把整轮读改写变成原子操作。超时表示实验没有在规定时间内完成,可能与环境或调度有关,不能当作 JMM 反例。daemon(守护线程)不会阻止 JVM 在其他非守护线程结束后退出,限时 join() 则限制主线程的等待时间,两者用于避免失败实验无限占用进程。
5. 进阶选读:release/acquire 发布普通字段
先掌握 volatile 发布链后再阅读这一节。VarHandle 用来选择更细的访问模式,不是常规业务为了发布一个对象就必须引入的工具;这里研究的是不同内存序契约,而不是推荐把简单代码改写得更复杂。
保存为 ReleaseAcquireDemo.java,只在 JDK 9+ 编译。写者先设置 payload=42,再用 setRelease 发布 ready=1;主线程用 getAcquire 观察到这个发布值后,才读取普通字段 payload。主线程在读数据之前不对写者调用 join(),以免线程终止的同步保证替代这里研究的 release/acquire 发布关系。Thread.onSpinWait() 是自旋等待提示,发布保证来自 VarHandle 访问模式。
java
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
public final class ReleaseAcquireDemo {
static final class Message {
int payload;
int ready;
}
private static final VarHandle READY;
static {
try {
READY = MethodHandles.lookup().findVarHandle(Message.class, "ready", int.class);
} catch (ReflectiveOperationException failure) {
throw new ExceptionInInitializerError(failure);
}
}
public static void main(String[] args) throws Exception {
Message message = new Message();
Thread writer = new Thread(() -> {
message.payload = 42;
READY.setRelease(message, 1);
}, "publisher");
writer.setDaemon(true);
writer.start();
long deadline = System.nanoTime() + 2000000000L;
while ((int) READY.getAcquire(message) != 1) {
if (System.nanoTime() - deadline >= 0) {
throw new IllegalStateException("publication timeout");
}
Thread.onSpinWait();
}
int observed = message.payload;
writer.join(2000);
if (writer.isAlive() || observed != 42) {
throw new AssertionError("unexpected payload=" + observed);
}
System.out.println("payload=" + observed);
}
}bash
javac ReleaseAcquireDemo.java
java ReleaseAcquireDemo在时限内完成发布且写者正常结束时,预期输出为 payload=42。成功输出不是 plain/opaque 也能安全发布的证据;删除 release/acquire 后即使多次运行都没有失败,也不能宣布两种协议等价。正确性压力测试与允许、禁止结果的分类见并发 A。
6. Monitor、park 与锁实现的版本边界
Monitor(监视器)可以先理解为对象关联的互斥与等待机制。synchronized (lock) 要取得 lock 对应的监视器才能进入代码块;同一线程可以重入,正常或异常退出时释放该次持有。实例同步方法使用实例的监视器,静态同步方法使用相应类镜像的监视器,二者不是同一把锁。
持有相应监视器的线程可以调用 wait() 等待条件;等待时释放这个监视器,返回前重新获取它,但不会释放线程持有的其他锁。notify()/notifyAll() 通知等待者重新竞争,不会立即把锁交出去。等待者必须在循环中检查条件,因为可能虚假唤醒,也可能有其他消费者抢先改变状态。完整协议见并发 04。
park() 是另一种线程等待原语,基于许可工作,不要求持有对象监视器,也不自动释放已经持有的锁。它可能虚假返回,所以返回后仍需分别判断中断、许可与条件是否满足。先区分这些等待语义,再分析对象头、自旋(反复尝试获取锁)或膨胀(转向较重的监视器实现路径)。
synchronized 的互斥、重入、异常退出解锁及同步语义由契约保证;对象头编码、自旋、膨胀/消胀和调度策略是实现。传统 HotSpot 图中的偏向/栈锁/Monitor 不应画成所有对象必须单向经历的生命周期。
JDK 15 的 JEP 374 默认禁用偏向锁并废弃相关选项。偏向锁是传统 HotSpot 针对同一线程反复获取锁的优化;Mark Word 是对象头中承载锁状态等信息的部分。较新 HotSpot 的锁实现继续演进,不能将 JDK 8 的 Mark Word 图套到所有版本。JDK 24 的 JEP 491 大幅改善虚拟线程的 monitor pinning:pinning 指虚拟线程无法从执行它的载体线程上卸载。使用时仍需按具体版本判断 native/foreign(本地或外部函数调用)等限制,见 10及并发 26。
BLOCKED 表示等待进入 Java 监视器,不直接展示对象头比特或内部锁模式。AQS(AbstractQueuedSynchronizer)是以同步状态和等待队列构建同步器的框架,基于它的锁在等待时常通过 park() 呈现 WAITING 或 TIMED_WAITING。这些线程状态描述等待方式,不能据此还原内部锁算法;被唤醒也不等于已经拿到锁,见并发 06。
7. 工程边界:不在本篇重复展开 JUC
- 原子更新的范围:一次 CAS 不自动保护任意多字段约束。ABA 指值从 A 变成 B 又回到 A,仅比较当前值可能发现不了这段变化;重试中的副作用也需要单独处理,见并发 07。
- 同步器的实现差异:AQS 的具体队列节点和 CAS 路径依版本而异,各同步器也不统一使用同一种锁算法。
- 乐观读的验证:
StampedLock乐观读允许写者同时修改数据,因此应先读到局部变量,再验证,失败后重新读取。读取过程中可能暂时不一致,不应执行副作用或依赖中间值进行危险访问;读多也不保证一定更快,见并发 16。 - 共享数据的布局:伪共享是不同线程频繁修改不同数据,却因数据位于同一缓存行而相互干扰。它依真实布局、缓存行和访问模式判断,调整字段顺序或手填
long不保证隔离;LongAdder.sum()也不是线性化快照,见并发 22。 - 线程局部数据的生命周期:
ThreadLocal条目以弱引用持有 key、强引用持有 value,key 被回收后 value 仍可能滞留。失效条目可能被后续操作清理,并非永远无法回收;嵌套上下文还需恢复原值,见并发 B。
排障先用 07建立线程/锁/CPU 证据,编译优化回 05。业务无竞态也可能性能差,不能靠换弱内存序、加 padding 或盲换锁作为第一步。
实验结果与参考资料
实验环境:Windows x64 10.0.26200、Intel i7-10700(16 逻辑 CPU),各用对应 javac 编译。OpenJDK 17+35-2724 与 Oracle 1.8.0_191-b12 的 VolatileIncrementDemo 各三次运行均为 volatile=1000、atomic=2000,正常退出;17 的 ReleaseAcquireDemo 三次均为 payload=42。
这是受控协议与反例验证,不枚举全部 JMM 允许执行,也没有 plain/opaque 的等价对照。结果不包含汇编、JCStress、AArch64 或现代锁布局证据,不能据此概括所有硬件与锁实现。
名词解释
| 名词 | 本文中的含义 |
|---|---|
| JMM | Java 内存模型,定义多线程读写的允许行为,不是堆栈分区图。 |
| happens-before | 用于推导可见性和有序性的关系,不是单纯墙钟上的先后。 |
| 内存屏障 | 约束特定重排或内存序的机制,最终实现依编译器和 CPU。 |
| VarHandle | 按指定访问模式读写变量的句柄,不同模式有不同契约。 |
| Monitor | 对象关联的互斥、重入与等待机制,是 synchronized 等操作的语义基础。 |
| CAS | 比较当前值并在匹配时原子更新的操作,不自动保护任意多步业务流程。 |