内存模型与happens-before：开发者与硬件的和平条约
在前文中，提到处理器通过一些特殊指令（如 LOCK、CMPXCHG、内存屏障等）来保障多线程环境下程序的正确性。然而，这种做法仍然存在几个显著问题。
1）底层指令实现复杂且晦涩：处理器指令的细节往往难以理解，开发者需要付出大量的时间和精力来掌握这些低级实现。
2）不同平台间的兼容性问题：不同硬件架构和操作系统对这些指令的支持和实现方式各不相同，这要求程序在设计时考虑到跨平台的兼容性和一致性。
3）多线程数据操作的复杂性：随着程序业务逻辑的多变，处理器与线程之间的内存访问依赖关系变得更加复杂，从而增加了程序出错的风险。
为了简化并发编程，解决这些问题，现代编程语言通常提供了抽象的内存模型，用以规范多线程环境下的内存访问行为。这种抽象使开发者无需关注底层硬件与操作系统实现细节，即可编写高效且可移植的并发程序。
以 Java 为例，Java语言采用了Java 内存模型（Java Memory Model，JMM）来提供这种抽象。 Java 内存模型的核心目的是通过支持诸如 volatile、synchronized、final 等同步原语，来确保在多线程环境下程序的原子性、可见性和有序性。这些原语确保了不同线程间的操作能够按照特定的规则正确协作。
此外，JMM 还引入了一个重要概念：happens-before 关系，旨在描述并发编程中操作之间的偏序关系。具体来说，偏序关系主要用于确保线程间操作的顺序性，避免因执行顺序不明确而导致的并发问题。
偏序关系在并发编程中的应用主要体现在以下两种情况。
1）程序顺序（Program Order）：指单线程中，由程序控制流决定的操作顺序。例如，如果操作 A 在操作 B 之前执行，那么我们可以认为 A <= B。
2）同步顺序（Synchronization Order）：指由并发控制机制（如锁、信号量等）所控制的操作顺序。例如，如果操作 A 释放了锁，而操作 B 随后获取了该锁，那么我们可以认为 A <= B。
除了 Java 之外，其他现代编程语言，如 Go、C++、Rust 等，也都实现了各自的 happens-before 关系机制，以确保并发程序的正确性和一致性。
Java内存模型的happens-before关系是用来描述两个线程操作的内存可见性。需注意这里的可见性，并不代表A线程的执行顺序一定早于B线程， 而是A线程对某个共享变量的操作对B线程可见。即A线程对变量a进行写操作，B线程读取到是变量a的变更值。
Java内存模型定义了主内存（Main memory），本地内存（Local memory），共享变量等抽象关系，来决定共享变量在多线程之间通信同步方式，即前面所说两个线程操作的内存可见性。其中本地内存，涵盖了缓存，写缓冲区，寄存器以及其他硬件和编译器优化等概念。
如图所示，如果线程A与线程B之间要通信的话，必须要经历下面2个步骤：
1）线程A把本地内存A中更新过的共享变量刷新到主内存中；
2）线程B到主内存中去读取线程A之前已更新过的共享变量。
为了进一步抽象这种线程间的数据同步方式，Java内存模型定义了下述线程间的happens-before关系。
1）程序顺序规则：单线程内，每个操作happens-before于该线程中的任意后续操作。
/* by 01022.hk - online tools website : 01022.hk/zh/hexconvert.html */
// Thread1内, A happens-before B，B happens-before C。
// 这意味着A一定会在B之前完成，B一定会在C之前完成。因此，可以确信y包含x+5的结果。
Thread1 {
x = 10; // A
y = x + 5; // B
print(y); // C
}
2）监视器锁规则：释放锁的操作happens-before之后对同一把锁的获取的锁操作。
/* by 01022.hk - online tools website : 01022.hk/zh/hexconvert.html */
// Thread1释放锁（B）happens-before Thread2获取锁（C）。
// 这意味着当Thread2打印x时，它看到的一定是"Thread1 data"，因为Thread1的修改操作和释放锁操作，都在Thread2获取锁之前完成。
lock = Lock()
Thread1 {
lock.acquire()
x = "Thread1 data" // A
lock.release() // B
}
Thread2 {
lock.acquire() // C
print(x) // D
lock.release()
}
3）volatile变量规则：volatile字段的写操作happens-before之后对同一字段的读操作。
// 对volatile字段的写操作（A）happens-before之后对同一字段的读操作（B）。
// 这意味着当Thread2读取x时，它看到的一定是100，因为Thread1的写操作在Thread2的读操作之前完成。
volatile int sharedData; // 声明一个volatile变量
Thread1 {
x = 100; // A
}
Thread2 {
int localData = x; // B
print(localData);
}
4）传递性规则：如果A happens-before B，且B happens-before C，那么A happens-before C。
// 如果Thread1 A happens-before Thread2 B，且Thread2 B happens-before Thread2 C，那么Thread1 A happens-before Thread2 C。
// 这意味着A一定会在C之前完成。因此，可以确信z包含(x+5)*2的结果，因为赋值给x的操作和计算x+5的操作都在计算y*2的操作之前完成。
Thread1 {
x = 10; // A
}
Thread2 {
y = x + 5; // B
z = y * 2; // C
print(z);
}
5）start()规则：如果线程A执行操作ThreadB.start()，那么A线程的ThreadB.start()操作happens-before于线程B中的任意操作。
// 如果Thread1执行操作ThreadB.start()，那么Thread1 A happens-before Thread2 C。
// 这意味着A一定会在C之前完成。因此，可以确信Thread1 x值为10，因为赋值给x的操作在打印x的操作之前完成。
Thread1 {
ThreadB.start(); // A
x = 10; // B
}
Thread2 {
print(x); // C
}
6）join()规则：如果线程A执行操作ThreadB.join()并成功返回，那么线程B中的任意操作 happens-before 线程A从ThreadB.join()操作成功返回。
// 如果线Thread1执行操作Thread2.join()，那么Thread2 D happens-before Thread1 C。
// 这意味着D一定会在C之前完成。因此，可以确信Thread1 x值为10，因为赋值给x的操作在打印x的操作之前完成。
Thread1 {
Thread2.start(); // A
Thread2.join(); // B
print(x); // C
}
Thread2 {
x = 10; // D
}
如上的happens-before关系中，与日常开发密切相关的是1、2、3、4四个规则。其中规则1满足了as-if-serial语义，即Java内存模型允许代码和指令重排序，只要不影响程序执行结果。规则2和3是通过synchronized、volatile关键字实现。结合规则1、2、3来看看规则4的具体使用，可以看到如下的代码，程序最终执行且得到正确结果。
// x, y, z被volatile关键字修饰
private volatile int x, y, z;
public void test() {
Thread a = new Thread(() -> {
// 基于程序顺序规则
// 没有数据依赖关系，可以重排序下面代码
int i = 0;
x = 2;
// 基于volatile变量规则
// 编译器插入storeload内存屏障指令
// 1）禁止代码和指令重排序
// 2）强制刷新变量x的最新值到内存
});
Thread b = new Thread(() -> {
int i = 0;
// 存在数据依赖关系，无法重排序下面代码
// 强制从主内存中读取变量x的最新值
y = x;
// 基于volatile变量规则
// 编译器插入storeload内存屏障指令
// 1）禁止代码和指令重排序
// 2）强制刷新变量y的最新值到内存
// 3）y = x；可能会被编译优化去除
y = 3;
// 编译器插入storeload内存屏障指令
// 1）禁止代码和指令重排序
// 2）强制刷新变量y的最新值到内存
});
Thread c = new Thread(() -> {
// 基于程序顺序规则
// 没有数据依赖关系，可以重排序下面代码
int i = 0;
// 基于volatile变量规则
// 强制从主内存中读取变量x和y的最新值
z = x * y;
// 编译器插入storeload内存屏障指令
// 1）禁止代码和指令重排序
// 2）强制刷新变量z的最新值到内存
});
// ...start启动线程，join等待线程
assert z == 6;
// 可以看到a线程对变量x变更，b线程对变量y变更，最终对线程c可见
// 即满足传递性规则
}
private int x, y, z;
public void test() {
Thread a = new Thread(() -> {
// synchronized，同步原语，程序逻辑将顺序串行执行
synchronized (this){
// 基于程序顺序规则
// 没有数据依赖关系，可以重排序下面代码
int i = 0;
x = 2;
// 基于监视器锁规则
// 强制刷新变量x的最新值到内存
}
});
Thread b = new Thread(() -> {
// synchronized，同步原语，程序逻辑将顺序串行执行
synchronized (this) {
int i = 0;
// 存在数据依赖关系，无法重排序下面代码
// 强制从主内存中读取变量x的最新值
y = x;
// 基于监视器锁规则
// 1）强制刷新变量y的最新值到内存
// 2）y = x；可能会被编译优化去除
y = 3;
// 强制刷新变量y的最新值到内存
}
});
Thread c = new Thread(() -> {
// synchronized，同步原语，程序逻辑将顺序串行执行
synchronized (this) {
// 基于程序顺序规则
// 没有数据依赖关系，可以重排序下面代码
int i = 0;
// 基于监视器锁规则
// 强制从主内存中读取变量x和y的最新值
z = x * y;
// 强制刷新变量z的最新值到内存
}
});
// ...start启动线程，join等待线程
assert z == 6;
// 可以看到a线程对变量x变更，b线程对变量y变更，最终对线程c可见
// 即满足传递性规则
}
总结：在混沌与秩序间搭建桥梁
Java内存模型是并发编程中连接开发者与硬件系统的关键桥梁。它依托可见性、有序性和原子性这三大核心原则，将复杂的并发问题转化为清晰的编程规范。当多个线程操作共享变量时，Java内存模型利用volatile、synchronized等机制，有效抑制了处理器优化带来的不确定性，同时兼顾了性能优化需求。其定义的happens-before关系，如同线程间的通信准则，以顺序性规则替代了对缓存刷新、指令重排等底层操作的直接操控。这种设计让开发者能够专注于业务逻辑，仅凭有限的同步手段就能构建出稳健的多线程程序。
Java内存模型的价值在于达成了三个重要平衡：它确保程序正确性不依赖于硬件实现细节；维持同步规则的简洁性以控制复杂度；让开发者能以较低的认知成本构建并发系统。这无疑是工程解耦的典范：用简洁的抽象来掌控复杂的世界。
很高兴与你相遇！
如果你喜欢本文内容，记得关注哦！！！
扫一扫
4232
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
