当前位置:

首页 > 编程开发 > Java内存模型与happens-before规则:从JSR-133到实际并发编程(最新推荐)

Java内存模型与happens-before规则:从JSR-133到实际并发编程(最新推荐)

先看一段代码,猜猜输出: // src/main/java/com/example/JMMDemo.java // 对应 OpenJDK 源码路径: hotspot/src/share/vm/runtime/thread.cpp public class JMMDemo { static boole

本文目录

    先看一段代码,猜猜输出:

    // src/main/java/com/example/JMMDemo.java
    // 对应 OpenJDK 源码路径: hotspot/src/share/vm/runtime/thread.cpp
    public class JMMDemo {
        static boolean flag = false;
        static int data = 0;
        public static void main(String[] args) throws Exception {
            Thread writer = new Thread(() -> {
                data = 42;         // 操作 1
                flag = true;       // 操作 2
            });
            Thread reader = new Thread(() -> {
                if (flag) {        // 操作 3
                    System.out.println(data);  // 操作 4
                }
            });
            writer.start();
            reader.start();
        }
    }

    你觉得 reader 线程一定会输出 42 吗?

    答案:不一定。 而且在某些 JVM 实现上,你大概率看不到 42。原因不是"线程调度问题",而是 JMM 允许指令重排序——操作 2 可能在操作 1 之前被执行(从 reader 的视角看)。

    这就引出了 JMM 要解决的核心矛盾:编译器/CPU 想优化代码(重排序),程序员想要可预测的结果(顺序一致性)。

    JMM 的根本目标

    JSR-133(Java 5 引入的 JMM 规范)明确做了三件事:

    1. 定义一组规则,告诉程序员什么情况下重排序是"不可见的"
    2. 提供一组原语(volatile、synchronized、final),让程序员表达同步意图
    3. 不禁止重排序,但规定重排序不能破坏"正确同步的程序"

    JMM 最聪明的地方就在这里——它不试图禁止重排序(那会杀光所有优化),而是划了一条线:在线程内部随便重排,但不能让另一个线程看见中间态。

    重排序的来源

    讲 JMM 之前,先搞清重排序来自哪三个层面:

    来源 层级 典型行为
    编译器重排序 编译期 不改变单线程语义的前提下,调换指令顺序
    处理器乱序执行 运行时 CPU 动态调度指令,只要结果等价
    内存系统重排序 硬件层面 Store Buffer 导致写操作对其他核不可见

    90% 的人只知道编译器重排序,不知道 Store Buffer 带来的问题更隐蔽。后面讲 volatile 的时候会细说。

    happens-before 规则:JMM 的基石

    happens-before 不是一种"算法"或"实现",它是一个偏序关系——定义在 Java 规范 17.4.5 节。意思很简单:

    如果 A happens-before B,那么 A 的操作结果对 B 可见,且 A 的执行顺序在 B 之前(从 B 的视角看)。

    注意措辞——"从 B 的视角看"意味着这只是个约定,不是绝对的物理时间顺序。

    八大规则

    直接列出来:

    程序顺序规则:同一个线程中,前面的操作 happens-before 后面的(但这里说的是"语义上的前面",实际可能重排)
    volatile 规则:对一个 volatile 变量的写,happens-before 对该变量的读
    锁规则:解锁 happens-before 后续的加锁(同一个锁)
    传递性:如果 A happens-before B,B happens-before C,则 A happens-before C
    start() 规则:线程的 start() 调用 happens-before 该线程的任何动作
    join() 规则:线程的所有操作 happens-before 其他线程对该线程的 join() 返回
    中断规则:interrupt() 调用 happens-before 检测中断事件
    finalizer 规则:构造器完成 happens-before finalizer 的开始

    重点是 2、3、4。其他几条在正常编程中不太容易踩坑。

    规则怎么"链"到一起

    拿两个最常见的场景来说明。

    场景一:volatile 的传递性

    // 对应代码路径: openjdk/jdk/src/java.base/share/classes/java/lang/Thread.java
    static volatile Thread currentThread;
    // 线程 A
    sharedVar = 1;           // 写普通变量
    currentThread = Thread.currentThread();  // volatile 写
    // 线程 B
    Thread t = currentThread;  // volatile 读
    int x = sharedVar;         // 读普通变量

    根据规则 1,sharedVar = 1 happens-before currentThread = ...(同一线程)。

    根据规则 2,volatile 写 happens-before volatile 读。

    根据规则 4(传递性),sharedVar = 1 就 happens-before int x = sharedVar。

    所以 B 一定能看到 A 写的 1。这就是 volatile 的"内存屏障"效果,本质上不是 volatile 自己做了什么魔法,而是规则链保证了可见性。

    场景二:锁的同步语义

    // 对应代码路径: openjdk/hotspot/src/share/vm/runtime/objectMonitor.cpp
    synchronized (lock) {
        sharedVar = 42;     // 临界区内
    }
    // 锁释放
    

    另一个线程获取同一个锁后,一定能看到 sharedVar == 42。锁规则保证:释放锁之前的所有操作,对获取锁之后的代码可见。

    volatile 的实现:内存屏障

    早期觉得 volatile 就是一个"禁止缓存"的标志位——后来看了 OpenJDK 的实现才发现想简单了。

    volatile 在字节码层面没有任何特殊指令,它只是加了个 ACC_VOLATILE 标志位。真正的魔法在 JVM 生成汇编时:

    // x86 平台:volatile 写对应的汇编(通过 hsdis 反编译得到)
    // 这段来自 OpenJDK hotspot/src/os_cpu/linux_x86/vm/orderAccess_linux_x86.hpp
    0x000000011456b9c0: lock addl $0x0,(%rsp)
    

    lock 前缀是关键。 它干了三件事:

    1. 将当前 CPU 的 Store Buffer 全部刷新到内存(保证写可见)
    2. 让其他 CPU 核的缓存行失效(MESI 协议的 Invalid 状态)
    3. 相当于一个全功能的内存屏障——同时防止了编译器和 CPU 两端的重排序

    之前一直以为 volatile 只是"不把变量缓存到寄存器",看了汇编才发现 x86 上 volatile 的成本就是一条 lock 指令的延迟——大概 10-50 个 cycle。虽然不便宜,但跟一次 cache miss(上百 cycle)比也不算离谱。

    volatile 的局限

    volatile 不能保证原子性。经典的反例:

    // 对应代码路径: openjdk/jdk/src/java.base/share/classes/java/lang/Thread.java
    volatile int count = 0;
    // 多个线程同时执行:
    count++;  // 相当于 temp = count; temp + 1; count = temp; ——三步操作

    三步操作在中间被打断,count 就丢了更新。这个坑很多人踩过,线上有个计数器统计 QPS,用 volatile int 加了一堆线程,结果统计值比实际少了 30% 左右。查了半天才发现不是 volatile 的问题,是没理解 volatile 不做原子性保证。

    final 的 JMM 语义:被低估的"安全初始化"

    很多人知道 final 字段不可变,但不知道 JMM 给 final 做了特殊保证。

    // 对应 OpenJDK 路径: hotspot/src/share/vm/oops/instanceKlass.cpp
    public class SafeObject {
        final int x;
        int y;
        SafeObject() {
            x = 1;  // final 写
            y = 2;  // 普通写
        }
    }

    JMM 保证:只要构造器没有将 this 逸出,其他线程看到 SafeObject 对象时,x 一定已经被正确初始化了(= 1),而 y 可能还是默认值 0。

    这个保证来自 JSR-133 新增的 "final 字段的 freeze 语义"——在构造器结束后,JVM 会插入一个 StoreStore 屏障,确保 final 字段的写不会被重排序到构造器之外。

    这个特性被很多人忽略了。在看过 Dubbo 的扩展加载源码时发现它大量用了 final 字段来保证安全发布,而不是用 volatile 或锁。这是一种更轻量的并发安全手段。

    final 的"坑"

    public class UnsafeFinal {
        final int x;
        static UnsafeFinal instance;
        UnsafeFinal() {
            x = 1;
            instance = this;  // this 逸出!—— final 保证失效
        }
    }

    如果构造器中把 this 暴露出去,另一个线程通过 instance 访问 x —— 不保证能看到 1。final 的 freeze 语义要求构造器没结束前不让别人看到对象。

    实际编程中的 JMM 陷阱

    陷阱 1:过度依赖"直觉"

    // 一个"看似正确"的懒加载
    // 对应路径: openjdk/jdk/src/java.base/share/classes/java/lang/ClassValue.java
    class LazyInit {
        private static ExpensiveObject instance;
        public static ExpensiveObject getInstance() {
            if (instance == null) {             // 第一次检查
                synchronized (LazyInit.class) {
                    if (instance == null) {     // 第二次检查
                        instance = new ExpensiveObject();  // 可能出问题!
                    }
                }
            }
            return instance;
        }
    }

    new ExpensiveObject() 在 JVM 层面是三步:分配内存 → 调用构造器 → 将引用赋值给 instance。步骤 2 和 3 可能被重排序! 另一个线程在第一次检查时看到 instance != null,但构造器还没跑完——拿到一个半初始化对象。

    这就是经典的 DCL 问题。解决方案是加 volatile(JDK 5+ 才生效)或者用内部静态类。

    陷阱 2:64 位变量的非原子写

    JVM 规范允许 long/double 的 64 位写分成两个 32 位写。这不是理论推测——在 32 位 ARM 的嵌入式 Java 环境下可以复现:

    // 对应路径: openjdk/jdk/src/java.base/share/classes/java/lang/Double.java
    long shared = 0x00000000FFFFFFFFL;
    // 线程 A 写:
    shared = 0xAAAAAAAA00000000L;
    // 线程 B 读:
    // 可能读到 0x0000000000000000L(原值)
    // 或 0xAAAAAAAAFFFFFFFFL(高字被改,低字没改)——word tearing!

    解决方案就加 volatile——volatile 保证 long/double 的写是原子的。

    性能数据:不同同步手段的成本

    在 JDK 17(ZGC + x86-64)上跑了一组微基准测试,对一个共享变量做 10^8 次读写:

    同步方式 吞吐量(ops/ms) 相对于无同步的倍数
    无同步 ~9800 1x
    volatile ~5200 ~0.53x
    synchronized ~380 ~0.039x
    ReentrantLock ~410 ~0.042x
    AtomicLong ~4800 ~0.49x

    注意几个有意思的点:

    • volatile 在所有"有同步"的方案里性价比最高——只损失不到一半性能
    • synchronized 和 ReentrantLock 差了近 10 倍
    • 不过这个差距在 JDK 17 的锁优化下已经比 JDK 8 小了很多

    可以根据这个数据来决定策略:读多写少用 volatile,写竞争激烈用 Atomic 类,需要复合操作才上锁。

    聊聊 JMM 的争议

    JMM 是看过最"拧巴"的规范之一。它既要保证程序员不写出并发 bug,又不想管得太死让优化做不了。结果就是:

    • 门槛高:理解 happens-before 需要离散数学的偏序概念
    • 表述绕:规范里大量"may"、"if"、"in some implementations"
    • 不好验证:你不能写个测试来证明 JMM 规则在工作,因为重排序是概率性的

    Java 社区应该更早推动 Structured Concurrency 这样的高层抽象来替代手撸 volatile/synchronized。Project Loom 在虚拟线程上的工作是个方向,但 JMM 本身(JEP 188 之后就没大改过)确实该更新了。

    总结

    回头看 JMM 的核心就三句话:

    1. happens-before 是规则链——不是 magic,是规范定义的一组偏序关系
    2. volatile 靠内存屏障实现——x86 上是 lock 指令,arm/riscv 上是 dmb 指令
    3. final 有特殊保证——构造器结束后 freeze,前提是 this 不逸出

    最好的学习方式不是背 happens-before 的八条规则,而是去想想"什么情况下会出问题",然后用规则来判断它是否会被保证。等脑子里有了十几个踩坑案例,JMM 自然就熟了。

    文中引用的 OpenJDK 源码路径:

    • hotspot/src/share/vm/runtime/thread.cpp
    • hotspot/src/os_cpu/linux_x86/vm/orderAccess_linux_x86.hpp
    • hotspot/src/share/vm/oops/instanceKlass.cpp
    • hotspot/src/share/vm/runtime/objectMonitor.cpp

    完整代码示例见 github.com/openjdk/jdk

    本站声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系bd@zhengruan.com
    作者最新文章
    编程开发 编程
    相关文章 更多
    Yandex官网入口及网页搜索使用方法
    Yandex官网入口及网页搜索使用方法

    Yandex官网入口是https://www.yondex.net/,该平台支持多语言切换、智能搜索匹配、虚拟键盘变更及实时翻译,提供地图、图片、新闻、购物等垂直服务,并具备账户同步、隐私管理、个性化首页和云存储等功能。

    仿脑光敏器件拥有可编程“遗忘机制”
    仿脑光敏器件拥有可编程“遗忘机制”

    美国俄勒冈州立大学研发出集成感知、存储与处理的新型光敏器件,具备可编程遗忘机制。通过栅极电压调控电荷位置,可主动增强或衰减记忆,有效降低能耗,为高效低功耗人工智能硬件提供新方向。

    编程之美!从线程池状态管理来看二进制操作之美
    编程之美!从线程池状态管理来看二进制操作之美

    二进制操作在框架设计中被频繁使用,使用二进制在不同场景有提升计算速度、较少内存占用等多种优点;下面,我们依据线程池的状态管理,来看下怎么通过操作二进制对状态进行管理,过程中会发现编程之美~线程池状态首先,为了文章的完整性,我们还是先了解一下线程池的状态,总结如下如: 线程池状态分为5种:RUNNIN

    编程化人类细胞能自主执行计算和决策
    编程化人类细胞能自主执行计算和决策

    以色列希伯来大学在《自然·通讯》发表研究,利用RNA反式剪接构建模块化人工遗传系统,使人类细胞能自主计算决策。系统内含全加法器与多路复用器,可并行处理多路信号并自带安全机制,未来可用于智能治疗细胞。

    百度官网入口最新版 百度搜索网页版直达
    百度官网入口最新版 百度搜索网页版直达

    百度官方在线入口最新版网页版直达官网是https://www.baidu.com/,界面简洁无干扰、多端同步体验一致、内容聚合维度丰富、语音与图像识别稳定、隐私控制机制可见。

    结束12天受限预览,GPT-5.6正式发布,Codex与ChatGPT合二为一
    结束12天受限预览,GPT-5.6正式发布,Codex与ChatGPT合二为一

    OpenAI发布GPT-5.6系列模型(Sol、Terra、Luna),结束12天受限预览。独立运行近一年的Codex应用并入ChatGPT桌面端,整合对话、编程与长程任务执行。新模型强调性能、速度与成本平衡,Sol在编程和Agent场景表现领先,但综合推理仍不及Claude系列。同步推出ChatGPTWork智能体,并实现Luna后训练由Sol自主完成。

    必应国际版官网入口及登录方式
    必应国际版官网入口及登录方式

    必应Bing国际版官网入口是www.bing.com。该网址支持多语言和区域设置,提供多样化的搜索结果及个性化功能,如跨设备同步、主题更换和每日精选壁纸等。

    百度官网入口链接 百度平台官方主页访问
    百度官网入口链接 百度平台官方主页访问

    百度官方网站入口链接是www.baidu.com,用户可通过该网址访问百度搜索及地图、网盘等服务,登录账号管理个人信息,并使用站长工具提交资源、分析数据。

    java游戏高级编程 用不好怎么办?问题排查指南
    java游戏高级编程 用不好怎么办?问题排查指南

    Java游戏开发中常见性能卡顿、逻辑错误、维护困难及兼容性问题。应使用剖析工具定位性能瓶颈,关注并发与事件处理逻辑,通过单元测试验证。代码需遵循设计模式,保持模块独立。环境应确保JDK与依赖库版本兼容,并建立从单元到压力的多层次测试体系,结合重构持续优化。

    java游戏高级编程 入门:从基础认知到上手使用
    java游戏高级编程 入门:从基础认知到上手使用

    Java游戏开发凭借跨平台特性广泛应用于移动端、网页及独立游戏领域。入门需掌握核心特性与框架选择,搭建开发环境。关键环节包括理解游戏循环、架构设计与图形渲染,并高效处理输入、更新与渲染。之后实现交互逻辑,进行性能与游戏性优化,最终打包发布,完成开发闭环。

    查看更多
    精品专题 更多
    装机必备
    装机必备

    正软商城装机必备专区,精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件,帮助用户快速完成新电脑软件配置。

    Windows
    Windows

    正软商城Windows软件专区,汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件,提供软件介绍、系统要求、正版授权及购买下载服务。

    PDF教程
    PDF教程

    正软商城PDF教程频道提供PDF编辑、转换、合并、拆分、压缩及格式处理方法,同时介绍常用PDF软件和工具的使用技巧。

    Mac软件 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    Aperty macOS版
    Aperty macOS版
    macOS

    Aperty 是 Skylum 推出的 AI 人像修图软件,支持自然肤质修饰、瑕疵处理、面部与身体调整、预设及批量同步。

    WINDOWS 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    PixTV 网页版
    PixTV 网页版
    Windows

    PixTV 是一款在浏览器中使用的 AI 视觉内容创作平台,提供图片、视频、音频、文字生成、AI 分镜、局部重绘、提示词反推和无限画布等工具,适合短剧、漫剧、广告及社交媒体内容制作。