Java 内存模型:happens-before 规则怎么落到字节码
问题背景:代码顺序不等于可见顺序
下面这段代码在单线程里没有问题,在多线程里却可能让读线程一直看不到写入,甚至看到 ready == true 而 value == 0:
public class VisibilityDemo {
private int value;
private boolean ready;
public void write() {
value = 42;
ready = true;
}
public void read() {
if (ready) {
System.out.println(value); // 没有同步时,可能输出 0
}
}
}
value 和 ready 都是普通字段,编译器可以调整指令顺序,CPU 可以使用缓存和写缓冲区,读线程也没有义务立刻看到另一个线程的写入。Java 内存模型(JMM)不规定“某个瞬间所有线程看到同一份内存”,而是规定在哪些条件下,一个线程的写入必须对另一个线程可见。这个条件就是 happens-before。
happens-before:跨线程的可见性契约
如果动作 A happens-before 动作 B,那么 A 的结果对 B 可见,并且 A 在顺序上约束 B。JMM 定义的核心规则包括:
- 程序顺序规则:同一个线程内,按源代码顺序,前面的动作 happens-before 后面的动作。
- 监视器规则:对同一个锁的
unlockhappens-before 后续的lock。 - volatile 规则:对同一个 volatile 变量的写 happens-before 后续的读。
- 线程启动规则:
Thread.start()happens-before 新线程中的任何动作。 - 线程终止规则:线程中的所有动作 happens-before 其他线程从
join()成功返回,或通过isAlive()观察到该线程结束。 - 中断规则:对线程的
interrupt()happens-before 被中断线程检测到中断。 - final 字段规则:构造函数结束时的 final 字段冻结,happens-before 读取到该对象引用之后的 final 字段读取。
这些规则还有传递性:若 A happens-before B,B happens-before C,则 A happens-before C。synchronized 之所以既能保证互斥又能保证可见性,是因为解锁和加锁构成了这一条链;CountDownLatch、Future.get() 等并发工具的可见性,最终也建立在内部锁、volatile 或 CAS 的 happens-before 关系上。
需要强调的是,happens-before 不等于“墙上时钟更早”。它描述的是可见性和允许的重排序边界,而不是物理执行时间。两个没有 happens-before 关系的操作,既可能按代码顺序执行,也可能被重排,且结果没有保证。
字节码里没有“内存屏障”这条指令
JMM 是规范,不是某条字节码。Class 文件里能看到的只是字段访问标志和指令:
ACC_VOLATILE(0x0040)标记 volatile 字段;ACC_FINAL(0x0010)标记 final 字段;ACC_SYNCHRONIZED(0x0020)标记同步方法;- 同步代码块编译为
monitorenter/monitorexit,字段读写仍是getfield/putfield。
getfield 和 putfield 本身没有“读屏障”“写屏障”参数。真正的屏障由 JVM 在解释器和 JIT 生成代码时插入:在 x86 的 TSO 模型下,volatile 读通常就是普通加载,volatile 写使用带 lock 前缀的指令或 xchg 来保证 StoreLoad 顺序;在 AArch64 上则可能生成 ldar / stlr 之类的获取、释放语义指令。synchronized 的监视器进入和退出则由 lock cmpxchg、对象头标记以及膨胀后的 ObjectMonitor 共同实现。
因此,javap 看到的是“语义声明”,不是最终硬件指令。JIT 还可以通过逃逸分析消除不会逃逸对象的锁;这时屏障消失并不违反 JMM,因为对象本来就没有被其他线程看到。
理解这一点,就不会在字节码里寻找 membar:屏障是 JVM 实现层对 JMM 的兑现方式,不是 Class 文件格式的一部分。同一个 putfield,在解释执行、C1 编译和 C2 编译后可能对应不同的指令序列;只要 happens-before 关系成立,程序结果就必须符合 JMM。
双重检查锁是观察这条链路的好例子:
public final class Singleton {
private static volatile Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
没有 volatile 时,构造函数的写入和引用发布之间没有 happens-before 约束:读线程可能先观察到非空引用,再看到尚未初始化完成的对象。volatile 写会给引用发布加上释放语义,volatile 读则建立获取语义,二者配对后,构造函数中的写入才对读线程可见。
用 javap 和 JIT 日志验证
先看 Class 文件中的访问标志和关键指令:
javap -classpath target/classes -c -p -v com.example.Singleton
输出中的关键片段如下(省略了偏移量):
private static volatile com.example.Singleton instance;
descriptor: Lcom/example/Singleton;
flags: (0x004a) ACC_PRIVATE, ACC_STATIC, ACC_VOLATILE
public static com.example.Singleton getInstance();
Code:
getstatic #7 // Field instance
ifnonnull ...
ldc #13 // class com/example/Singleton
monitorenter
...
new #16
dup
invokespecial #18 // Method "<init>":()V
putstatic #7 // Field instance
monitorexit
可以看到,volatile 只体现为字段标志,putstatic 并没有附带屏障参数;monitorenter / monitorexit 则明确对应监视器规则。若把方法声明为 synchronized,字节码里不再出现这两个指令,而是方法访问标志带上 ACC_SYNCHRONIZED,由 JVM 在调用边界完成加锁。monitorenter 之后的异常表会保证无论正常返回还是抛出异常都执行 monitorexit;这也是同步块比手写 lock()/unlock() 更不容易漏释放的原因。
要观察 JIT 生成的机器码,需要 hsdis 插件:
java -XX:+UnlockDiagnosticVMOptions \
-XX:CompileCommand=compileonly,com.example.Singleton::getInstance \
-XX:+PrintAssembly -cp target/classes com.example.Singleton
如果环境没有 hsdis,会提示无法加载反汇编器,此时不要据此判断屏障不存在。不同 CPU 的输出不同:x86 上重点看 lock 前缀和 cmpxchg,AArch64 上重点看 ldar、stlr 或 dmb。结论应以目标架构和 JDK 版本的实现为准。
PrintAssembly 默认只输出热点编译结果,且 compileonly 会改变内联决策,因此它适合做机制验证,不适合拿单次输出去推断全量性能。
另一个常见误区是认为 volatile 能保证复合操作原子性:
private volatile int count;
public void increment() {
count++; // getfield、iadd、putfield 三步,仍会丢更新
}
volatile 只保证单次读写的可见性和顺序,count++ 仍是读改写序列。需要原子性时应使用 AtomicInteger、LongAdder,或用同一把锁保护整个不变式。
实践建议与踩坑
- 优先用不可变对象和 final 字段发布。 final 字段在构造完成后有冻结语义,但前提是
this没有在构造期间逃逸。把对象注册到监听器、线程池或静态集合之前,先完成所有字段初始化。 - 不要用 volatile 替代锁。 多个字段之间存在不变式时,volatile 只能保证单个字段的可见性,不能保证组合状态一致。例如“余额和流水必须同时更新”,仍然需要锁或 CAS 循环。
- volatile 数组只保护引用。
volatile byte[] buffer能保证数组引用可见,但buffer[0]的元素读写没有 volatile 语义;需要元素级可见性时用VarHandle的getVolatile/setVolatile,或改用AtomicIntegerArray等原子数组。AtomicReferenceArray并不适用于基本类型数组。 - 锁对象要私有且稳定。 不要锁字符串字面量、被 intern 的字符串或自动装箱对象,它们可能被其他代码共享;也不要锁可变的公开字段。推荐
private final Object lock = new Object()。 - 注意 64 位读写的原子性边界。 JLS 允许非 volatile 的 long/double 读写不是原子的,32 位 VM 上可能出现撕裂;对共享的 long/double 使用 volatile 或原子类,不要依赖硬件“通常原子”。
- 写完并发代码要用工具验证。 单测很难稳定复现重排序,可以用 JCStress 做压力测试,用
jstack观察锁竞争,用 JFR 的 Java Monitor 事件确认阻塞点,再回到 happens-before 规则解释可见性。
- 点赞
- 收藏
- 关注作者
评论(0)