happens-before规则

最新推荐文章于 2025-04-24 17:49:11 发布
最新推荐文章于 2025-04-24 17:49:11 发布
阅读量778 收藏 4
点赞数 1
分类专栏： JVM 文章标签： happens-before
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/java_collect/article/details/103953265
版权
本文详细介绍了Java内存模型中的happens-before原则，包括其定义、意义和具体规则，如程序顺序规则、监视器锁规则等。happens-before原则确保了多线程环境下操作的内存可见性和顺序，同时JMM允许在不改变执行结果的情况下进行一定的重排序优化，以提升性能。此外，文章还探讨了JMM的设计考量和与编译器、处理器重排序的关系。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

happens-before定义

       happens-before用来指定两个操作之间的执行顺序，如果A线程的写操作与B线程的读操作之间存在happens-before关系，尽管写操作和读操作在不同的线程中执行，但JMM向程序员保证写操作的结果将对读操作可见。我的理解是，JMM通过happens-before规则定义了一个规范，向程序员提供一种简单可靠的跨线程内存可见性的保证，规范对编译器和处理器的重排序做了约束（尽可能的利用了CPU的指令优化）。具体解释如下：

  1. 如果一个操作happens-before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。
  2. 两个操作之间存在happens-before关系，并不意味着Java平台的具体实现必须要按照happens-before关系指定的顺序来执行。如果重排序之后的执行结果，与按happens-before关系来执行的结果一致，那么这种重排序并不非法（也就是说，JMM允许这种重排序）

       上面的1）是JMM对程序员的承诺。从程序员的角度来说，可以这样理解happens-before关系：如果A happens-before B，那么Java内存模型将向程序员保证——A操作的结果将对B可见，且A的执行顺序排在B之前。注意，这只是Java内存模型向程序员做出的保证！
       上面的2）是JMM对编译器和处理器重排序的约束原则。正如前面所言，JMM其实是在遵循一个基本原则：只要不改变程序的执行结果（指的是单线程程序和正确同步的多线程程序），编译器和

最低0.47元/天 解锁文章
happens-before规则——理解happens-before规则
秃了也弱了
08-11 1677
happens-before 是 JMM 最核心的概念。对应 Java 程序员来说，理解 happens-before是理解 JMM 的关键。从 JDK 5 开始，Java 使用新的 JSR-133 内存模型（除非特别说明，本文针对的都是JSR-133 内存模型）。JSR-133 使用 happens-before 的概念来阐述操作之间的内存可见性。在 JMM 中，如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必 须要存在 happens-before 关系。...
深入理解 Happens-Before 规则及其在多线程中的作用
一碗黄焖鸡三碗米饭的博客
04-08 1261
在多线程环境下，JMM通过规则来定义哪些操作对其他线程是可见的，以此保证线程间的正确同步。也就是说，当一个操作发生在另一个操作之前，并且这两个操作之间存在关系时，前一个操作对后一个操作的影响是可见的。
Happens-Before原则
小红的布丁的博客
04-24 410
Happens-Before是JMM的核心概念之一，是一种可见性模型，保障多线程环境下前一个操作的结果相对于后续操作是可见的。
happens-before 规则
热门推荐
当时若不登高望、谁信东流海洋深
05-21 1万+
1.happens-before 定义 happens-before的概念最初由Leslie Lamport在其一篇影响深远的论文（《Time，Clocks and the Ordering of Events in a Distributed System》）中提出，有兴趣的可以google一下。JSR-133使用happens-before的概念来指定两个操作之间的执行顺序。由于这两个操...
Happens-Before规则
米奇罗
11-29 439
1. 前言 从 JDK 5开始，Java 使用新的 JSR-133 内存模型，使用 happens-before 的概念来阐述操作间的可见性。 2. 定义 JSR-133 对Happens-Before 的定义： Happens-Before Relationship Two actions can be ordered by a happens-before relationship. If...
Happens-before 规则
qq_45378738的博客
03-22 345
指令重排 程序进行编译阶段都会对代码进行优化（即进行重排）来提高运行效率。指令重排会在不该变单线程程序予以的前提下，重新安排语句的指向顺序。 例如 singletion = new Singletion(); 这句话的执行顺序为： 分配内存 初始化 对象指向内存空间 但在指令重排后可能为： 分配内存 对象指向内存空间 初始化 在并发情况下，指令重排会导致一个线程还没初始化或部分初始化就被另一个线程拿到，这是得到的值为空或错误。 所以在并发执行的情况下，指令重排会发生二义性，即按照不同的执行逻辑，会得
06-Java内存模型JMM与Happens-Before规则详解-147093244.md
最新发布
05-07
Happens-Before规则是JMM中的一个关键概念，它提供了一种确保程序执行顺序和内存一致性的方法，确保了代码的正确性。 硬件层面的挑战主要包括CPU缓存一致性问题、指令重排序以及多级存储架构。这些硬件特性会导致...
Go内存屏障原理：Happens-Before规则的实际应用.pdf
04-28
文档支持目录章节跳转同时还支持阅读器左侧大纲显示和章节快速定位，文档内容完整、条理清晰。文档内所有文字、图表、函数、目录等元素均显示正常，无任何异常情况，敬请您放心查阅与使用。文档仅供学习参考，请勿...
深入理解happens-before规则
luzhensmart的专栏
05-13 303
为什么会有happens-before 规则？ 因为jvm会对代码进行编译优化，指令会出现重排序的情况，为了避免编译优化对并发编程安全性的影响，需要happens-before规则定义一些禁止编译优化的场景，保证并发编程的正确性。 public class VolatileExample { int x = 0 ; volatile boolean v = false; ...
Happens-Before原则（先行发生原则）
FengDuidui的博客
07-10 1962
Happens-Before 从jdk5开始，java使用新的JSR-133内存模型，基于Happens-Before的概念来阐述操作之间的内存可见性。 Happens-Before定义 如果一个操作Happens-Before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。 两个操作之间存在Happens-Before关系，并不意味着一...
Happens-Before规则详解
Herishwater的博客
07-14 705
本文为《Java高并发》第四篇文章，首发于。在《》一节中提到编译优化会带来有序性问题，具体来说就是JIT编译器会进行指令重排序（InstructionReorder）优化。优化措施引发的有序性问题，Java语言肯定会注意到，所以就引入了Happens-Before（先行发生）原则，它是JMM最核心的概念，在中提到了如何保证可见性和有序性，都和该原则有关联。对应Java程序员来说，理解Happens-before是理解JMM的关键。...
理解happens-before规则
weixin_57763462的博客
08-26 157
因为jvm会对代码进行编译优化，指令会出现重排序的情况，为了避免编译优化对并发编程安全性的影响，需要happens-before规则定义一些禁止编译优化的场景，保证并发编程的正确性。 public class VolatileExample { int x = 0 ; volatile boolean v = false; public void writer(){ x = 42; v = true; } public voi
【学习JVM】happens-before规则
度窝-笔记
02-14 343
happens-before规则 程序顺序原则，即在一个线程内必须保证语义串行性，也就是说按照代码顺序执行。 锁规则 解锁(unlock)操作必然发生在后续的同一个锁的加锁(lock)之前，也就是说，如果对于一个锁解锁后，再加锁，那么加锁的动作必须在解锁动作之后(同一个锁)。 volatile规则 volatile变量的写，先发生于读，这保证了volatile变量的可见性，简单的理解就...
说明下java的happens-before 规则
02-26
<think>好的，我需要解释一下Java的happens-before规则。首先，我得回想一下这个规则的基本概念。happens-before是Java内存模型中的一个核心概念，用于确定多线程环境下操作的可见性和有序性。用户可能已经了解volatile关键字，但happens-before更广泛，涉及更多同步机制。 接下来，我需要明确happens-before的定义。它不是一个实际的时间顺序，而是一个保证，即如果一个操作happens-before另一个操作，那么第一个操作的结果对第二个操作是可见的。这涉及到编译器和处理器的重排序问题，需要确保在这些优化下，程序的执行结果符合预期。 然后，我应该列举具体的happens-before规则。比如程序顺序规则、锁规则、volatile变量规则、线程启动规则、线程终止规则、中断规则、终结器规则等。每个规则都需要简要说明，并举例子帮助理解。例如，程序顺序规则指的是同一线程中的每个操作happens-before后续操作，但实际执行时可能重排序，只要不影响结果。 用户可能想知道为什么需要这些规则，所以需要解释它们的作用，比如确保线程间的正确同步，避免数据竞争和内存可见性问题。同时，要对比其他语言如C++的处理方式，但这里集中在Java上。 还要注意happens-before与指令重排的关系，说明JVM如何通过这些规则限制重排序，保证多线程程序的正确性。可能需要提到内存屏障，但不用深入底层细节，保持解释在Java层面。 另外，用户可能有疑问，比如单线程下是否适用happens-before，需要说明单线程内遵循程序顺序，但多线程下需要显式同步机制来建立happens-before关系。 最后，通过一个例子来展示happens-before如何工作，比如两个线程通过synchronized块或volatile变量进行同步，如何确保可见性。同时，强调正确使用这些机制的重要性，否则可能导致难以调试的并发问题。 总结时，要重申happens-before的重要性，并建议在实际开发中如何应用这些规则，比如使用现有的同步工具而不是手动处理，避免错误。</think>--- ### Java 的 **happens-before 规则** 是内存模型（JMM）的核心概念，用于定义多线程环境下操作的 **可见性** 和 **有序性**。它并非字面意义上的“时间先后”，而是通过一组规则保证：**如果一个操作 A happens-before 操作 B，那么 A 的结果对 B 是可见的**，且编译器和处理器不会对这两个操作进行破坏规则的指令重排。 --- ### **1. happens-before 的六条基本规则** 以下是 Java 内存模型定义的 happens-before 规则： #### **(1) 程序顺序规则（Program Order Rule）** - **单线程内**，代码的书写顺序（程序顺序）决定了操作的执行顺序。 - **但允许指令重排**：只要重排不影响单线程的执行结果（即遵循 as-if-serial 语义）。 ```java int x = 1; // 操作 A int y = x + 2; // 操作 B：A happens-before B ``` --- #### **(2) 锁规则（Monitor Lock Rule）** - **解锁操作** happens-before **后续的加锁操作**（同一锁）。 - 保证锁释放前修改的变量对下一个加锁线程可见。 ```java synchronized (lock) { x = 42; // 操作 A（解锁时，A 的修改对其他线程可见） } // 解锁 happens-before 下一个加锁操作 synchronized (lock) { System.out.println(x); // 操作 B：读到 42 } ``` --- #### **(3) volatile 变量规则（Volatile Variable Rule）** - **对 volatile 变量的写操作** happens-before **后续对该变量的读操作**。 - 禁止指令重排，并强制刷新主内存。 ```java volatile boolean flag = false; // 线程 A flag = true; // 写操作 happens-before 线程 B 的读操作 // 线程 B if (flag) { // 一定能读到 true // 执行操作 } ``` --- #### **(4) 线程启动规则（Thread Start Rule）** - **线程的 `start()` 方法调用** happens-before **该线程的任何操作**。 ```java int x = 10; Thread t = new Thread(() -> { System.out.println(x); // 能读到 x = 10（父线程的修改对子线程可见） }); x = 20; // 修改在 start() 前，对子线程可见 t.start(); ``` --- #### **(5) 线程终止规则（Thread Termination Rule）** - **线程的所有操作** happens-before **其他线程检测到该线程终止**（如 `t.join()` 或 `t.isAlive()` 返回 false）。 ```java Thread t = new Thread(() -> { x = 42; }); t.start(); t.join(); System.out.println(x); // 保证读到 x = 42 ``` --- #### **(6) 中断规则（Interruption Rule）** - **对线程的 `interrupt()` 调用** happens-before **被中断线程检测到中断事件**（如抛出 `InterruptedException` 或调用 `isInterrupted()`）。 ```java Thread t = new Thread(() -> { try { Thread.sleep(1000); } catch (InterruptedException e) { // 中断事件在 interrupt() 调用后触发 } }); t.start(); t.interrupt(); // happens-before 线程抛出异常 ``` --- ### **2. 传递性** 如果 **A happens-before B**，且 **B happens-before C**，则 **A happens-before C**。 这一特性使得跨线程的可见性得以传递。 ```java // 线程 A synchronized (lock) { x = 1; // 操作 A } // 解锁 happens-before 线程 B 加锁 // 线程 B synchronized (lock) { y = x; // 操作 B：读到 x = 1 } // 解锁 happens-before 线程 C 加锁 // 线程 C synchronized (lock) { z = y; // 操作 C：读到 y = 1 } ``` --- ### **3. happens-before 的实际意义** - **可见性**：确保一个线程的修改对其他线程可见。 - **有序性**：限制编译器和处理器的指令重排，避免破坏程序逻辑。 - **简化同步**：开发者无需关心底层内存细节，只需遵循规则设计同步机制。 --- ### **4. 示例分析** #### **错误代码（缺乏 happens-before 关系）** ```java int value = 0; boolean flag = false; // 线程 A value = 42; // 操作 1 flag = true; // 操作 2（非 volatile） // 线程 B while (!flag); // 操作 3 System.out.println(value); // 操作 4：可能输出 0 ``` - **问题**：线程 A 的 `flag` 不是 volatile，操作 1 和 2 可能被重排，且线程 B 可能看不到 `value` 的更新。 --- #### **修正代码（通过 volatile 建立 happens-before）** ```java volatile boolean flag = false; // 线程 A value = 42; // 操作 1 flag = true; // 操作 2（volatile 写） // 线程 B while (!flag); // 操作 3（volatile 读） System.out.println(value); // 操作 4：必输出 42 ``` - **解决**：volatile 写操作 2 happens-before volatile 读操作 3，且操作 1 不会被重排到操作 2 之后。 --- ### **5. 总结** - **happens-before 是逻辑关系**，而非物理时间顺序。 - **正确同步**（如锁、volatile、原子类）可以建立 happens-before，保证线程安全。 - **违反规则**会导致数据竞争和不可预测的结果。 **开发建议**：优先使用 `synchronized`、`volatile` 或 `java.util.concurrent` 工具类，而非手动控制内存可见性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值