当前位置：首页 > wzjs >正文

定制软件的平台电脑系统优化软件排行榜

wzjs 2025/9/19 14:47:12

定制软件的平台,电脑系统优化软件排行榜,市场监督管理局投诉电话是多少,wordpress视频类主题Happens-Before规则(前言) Happens-Before规则是 Java 内存模型（JMM）中用于定义线程间操作可见性和有序性的一种规范。它的核心目的是：确保一个线程的某些操作结果对其他线程是可见的，并且这些操作在时间上的顺序不会被重排序破…

Happens-Before规则(前言)

Happens-Before规则 是 Java 内存模型（JMM）中用于定义线程间操作可见性和有序性的一种规范。它的核心目的是：确保一个线程的某些操作结果对其他线程是可见的，并且这些操作在时间上的顺序不会被重排序破坏。

简单来说，如果操作 A Happens-Before 操作 B，那么操作 A 的结果对操作 B 是可见的，并且操作 A 在逻辑上先于操作 B 发生。

Happens-Before的核心作用

保证可见性：
- 确保一个线程对共享变量的修改对其他线程可见。
保证有序性：
- 防止编译器或处理器对指令进行重排序，从而破坏程序的逻辑顺序。

Happens-Before规则的具体内容

以下是 Java 内存模型中定义的 Happens-Before 规则：

1. 程序顺序规则（Program Order Rule）

在同一个线程内，按照代码的书写顺序，前面的操作 Happens-Before 后面的操作。
注意：这只是逻辑上的顺序，实际执行时可能会因为指令重排序而改变。

例子：

int x = 1; // 操作1
int y = 2; // 操作2
// 操作1 Happens-Before 操作2

2. volatile变量规则（Volatile Variable Rule）

对一个 volatile 变量的写操作 Happens-Before 后续对该变量的读操作。
这是 volatile 关键字的核心特性之一：它不仅能保证可见性，还能禁止指令重排序。

例子：

class VolatileExample {private volatile boolean flag = false;public void writer() {flag = true; // 写操作}public void reader() {if (flag) {  // 读操作System.out.println("Flag is true");}}
}
// 写操作 Happens-Before 读操作

3. 锁规则（Lock Rule）

解锁操作 Happens-Before 后续的加锁操作。
这意味着一个线程释放锁后，另一个线程获取锁时可以看到之前线程的所有操作结果。

例子：

class LockExample {private int x = 0;private final Object lock = new Object();public void writer() {synchronized (lock) {x = 42; // 写操作} // 解锁操作}public void reader() {synchronized (lock) {System.out.println(x); // 读操作} // 加锁操作}
}
// 解锁操作 Happens-Before 加锁操作

4. 线程启动规则（Thread Start Rule）

线程的 start() 方法调用 Happens-Before 该线程中的任何操作。

例子：

class ThreadStartExample {private int x = 0;public void startThread() {x = 42; // 操作1Thread t = new Thread(() -> {System.out.println(x); // 操作2});t.start();}
}
// 操作1 Happens-Before 操作2

5. 线程终止规则（Thread Termination Rule）

一个线程的所有操作 Happens-Before 其他线程检测到该线程已经终止（如通过 Thread.join() 或 Thread.isAlive() 判断）。

例子：

class ThreadTerminationExample {private int x = 0;public void runThreads() throws InterruptedException {Thread t = new Thread(() -> {x = 42; // 操作1});t.start();t.join(); // 等待线程结束System.out.println(x); // 操作2}
}
// 操作1 Happens-Before 操作2

6. 中断规则（Interruption Rule）

调用线程的 interrupt() 方法 Happens-Before 被中断线程检测到中断事件（如调用 isInterrupted() 或捕获 InterruptedException）。

例子：

class InterruptExample {public void interruptThread(Thread t) {t.interrupt(); // 操作1}public void checkInterrupt(Thread t) {if (t.isInterrupted()) { // 操作2System.out.println("Thread is interrupted");}}
}
// 操作1 Happens-Before 操作2

7. 传递性规则（Transitivity Rule）

如果操作 A Happens-Before 操作 B，且操作 B Happens-Before 操作 C，那么操作 A Happens-Before 操作 C。

例子：

class TransitivityExample {private int x = 0;private volatile boolean flag = false;public void writer() {x = 42;           // 操作Aflag = true;      // 操作B}public void reader() {if (flag) {       // 操作CSystem.out.println(x); // 操作D}}
}
// 操作A Happens-Before 操作B，操作B Happens-Before 操作C
// 因此，操作A Happens-Before 操作D

关键点：

Happens-Before 并不一定是时间上的先后顺序，而是逻辑上的顺序。
它不仅保证了可见性，还防止了指令重排序导致的问题。
常见的 Happens-Before 规则包括程序顺序规则、volatile规则、锁规则、线程启动规则等。

解决并发问题理解的第一个维度：

核心知识点JMM本质上可以理解为，Java 内存模型规范了 JVM 如何提供按需禁用缓存和编译优化的方法。

具体来说，这些方法包括：
volatile、synchronized 和 final 三个关键字
Happens-Before 规则

解决并发问题理解的第二个维度：可见性，有序性，原子性

原子性

在Java中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不执行。

请分析以下哪些操作是原子性操作：

x = 10;        //语句1: 直接将数值10赋值给x，也就是说线程执行这个语句的会直接将数值10写入到工作内存中
y = x;         //语句2: 包含2个操作，它先要去读取x的值，再将x的值写入工作内存，虽然读取x的值以及 将x的值写入工作内存 这2个操作都是原子性操作，但是合起来就不是原子性操作了。
x++;           //语句3： x++包括3个操作：读取x的值，进行加1操作，写入新的值。
x = x + 1;     //语句4： 同语句3

上面4个语句只有语句1的操作具备原子性。也就是说，只有简单的读取、赋值（而且必须是将数字赋值给某个变量，变量之间的相互赋值不是原子操作）才是原子操作。

基本数据类型中，除了long和double外，其他类型（如int、short、byte、char、boolean、float）的读写操作在JVM中通常是原子的。
long和double类型的读写操作可能不是原子的，因为它们在某些平台上可能会被拆分为两个32位的操作执行。

例子：

// 原子性操作
int x = 10; // 原子操作
x = 20;     // 原子操作// 非原子性操作(可能)
long y = 123456789L; // 在某些平台上可能不是原子操作

从上面可以看出，Java内存模型只保证了基本读取和赋值是原子性操作，如果要实现更大范围操作的原子性，可以通过synchronized和Lock来实现。
由于synchronized和Lock能够保证任一时刻只有一个线程执行该代码块，那么自然就不存在原子性问题了，从而保证了原子性。

可见性
Java提供了volatile关键字来保证可见性。
当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存(volatile的作用是通过禁止指令重排序和确保缓存一致性协议（如MESI）来实现可见性)，当有其他线程需要读取时，它会去内存中读取新值。
而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。

另外，通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

注意： volatile并不能完全替代synchronized或Lock，因为它只保证可见性和有序性，但不保证复合操作的原子性。

volatile通过缓存一致性协议（如MESI）确保一个线程对共享变量的修改对其他线程立即可见。
volatile适用于单个变量的可见性问题，但如果涉及多个变量或复合操作，仍然需要使用synchronized或Lock。

例子：

class VolatileExample {private volatile boolean flag = true;public void stop() {flag = false; // 修改flag，其他线程会立即看到}public void run() {while (flag) {// 执行任务}}
}

有序性
在Java里面，可以通过volatile关键字来保证一定的“有序性”。另外可以通过synchronized和Lock来保证有序性，很显然，synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。当然JMM是通过Happens-Before 规则来保证有序性的
synchronized和Lock通过引入内存屏障（Memory Barrier）来防止指令重排序，从而间接保证有序性。
volatile也可以通过禁止指令重排序来保证有序性。

例子：

// 使用volatile保证有序性
class VolatileOrderExample {private volatile boolean initialized = false;private int value = 0;public void init() {value = 42;          // 操作1initialized = true;  // 操作2，volatile保证不会被重排序到操作1之前}public void use() {if (initialized) {   // volatile保证可见性和有序性System.out.println(value);}}
}

Happens-Before规则不仅用于保证有序性，还用于确保可见性。

常见的Happens-Before规则包括：

程序顺序规则：同一个线程内，前面的操作Happens-Before后面的操作。
锁规则：解锁操作Happens-Before后续的加锁操作。
volatile规则：对volatile变量的写操作Happens-Before后续的读操作。
线程启动规则：线程启动操作Happens-Before该线程内的任何操作。
线程终止规则：线程内的任何操作Happens-Before其他线程检测到该线程结束。

例子：

class HappensBeforeExample {private int x = 0;private volatile boolean flag = false;public void writer() {x = 42;           // 操作1flag = true;      // 操作2，volatile写}public void reader() {if (flag) {       // 操作3，volatile读System.out.println(x); // 操作4，一定能打印42}}
}