Java 内存模型:happens-before 规则怎么落到字节码

举报
yd_254127822 发表于 2026/11/18 08:31:14 2026/11/18
【摘要】 JMM 的 happens-before 规则保障可见性与有序性,但它不是一条字节码。本文结合 volatile、synchronized、双重检查锁以及 javap 和 JIT反汇编,说明这些规则如何由字段标志、监视器指令与底层屏障实现。

问题背景:代码顺序不等于可见顺序

下面这段代码在单线程里没有问题,在多线程里却可能让读线程一直看不到写入,甚至看到 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 后面的动作。
  • 监视器规则:对同一个锁的 unlock happens-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 规则解释可见性。
【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0)

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。