心理解：如果操作 A happens-before 操作 B，那么 A 的执行结果对 B 可见。这个原则主要解决了 Java 并发编程中的两个关键问题：
可见性问题：由 CPU 缓存引起
有序性问题：由编译器优化和指令重排引起
二、Happens-before 的具体规则#
1. 程序顺序性规则#
在单线程中，按照程序代码顺序，前面的操作 happens-before 后面的操作。
关键点：
有依赖关系：操作间存在数据依赖时，顺序不可重排
无依赖关系：操作间无数据依赖时，可以重排序，但要保证单线程执行结果不变
int a = 1; // 操作A
int b = 2; // 操作B（与A无依赖，可重排）
int c = a + 1; // 操作C（依赖A，必须在A之后）
int d = b * 2; // 操作D（依赖B，必须在B之后）
// 可能的执行顺序：
// ✓ A → B → C → D（原始顺序）
// ✓ B → A → C → D（B与A无依赖，可交换）
// ✗ C → A → B → D（C依赖A，不能在A之前）
2. volatile 变量规则#
对 volatile 变量的写操作 happens-before 后续对该变量的读操作。
volatile int flag = 0;
// 线程A
flag = 1; // 写操作
// 线程B
if (flag == 1) { // 读操作
// 能看到线程A的写入
}
3. 传递性规则#
如果 A happens-before B，且 B happens-before C，那么 A happens-before C。
4. 锁规则（Monitor Lock Rule）#
对一个锁的解锁操作 happens-before 后续对这个锁的加锁操作。
synchronized (lock) {
// 临界区代码
} // 解锁
// 其他线程
synchronized (lock) { // 加锁
// 能看到前一个线程在临界区的所有操作
}
5. 线程启动规则#
线程 A 中调用线程 B 的 start() 方法之前的所有操作，happens-before 线程 B 中的任意操作。
6. 线程终止规则#
线程 B 中的所有操作 happens-before 线程 A 中调用 B.join() 方法成功返回后的操作。
public class VisibilityDemo {
static int var = 0;
public static void main(String[] args) throws InterruptedException {
// 主线程操作
var = 10; // ① 主线程修改
Thread B = new Thread(() -> {
// 子线程B能看到①的修改（线程启动规则）
var = 66; // ② 子线程修改
});
B.start(); // 启动子线程
B.join(); // 等待子线程结束
// ③ 主线程能看到②的修改（线程终止规则）
System.out.println(var); // 输出：66
}
}
执行流程：
根据线程启动规则：主线程的 var = 10 happens-before 子线程 B 的所有操作
根据线程终止规则：子线程 B 的 var = 66 happens-before 主线程 join() 之后的操作
因此主线程最终能看到 var 的值为 66
7. final 字段规则#
在构造函数中对 final 字段的写入，happens-before 其他线程对该对象的 final 字段的读取。
public class FinalExample {
private final int value;
public FinalExample(int value) {
this.value = value; // 构造函数中的写入
}
// 其他线程读取时，保证能看到构造函数中的赋值
public int getValue() {
return value;
}
}
三、总结#
Happens-before 原则是 Java 并发编程的基石，它通过定义操作间的可见性关系，让开发者能够在不了解底层硬件细节的情况下，编写正确的并发程序。掌握这些规则，是写出线程安全代码的关键。
