深入理解 Java 内存模型（JMM）

可见性

可见性指当一个线程修改了共享变量的值，其他线程能够立即看到修改后的值。

private boolean running = true; // 主内存中的变量

public void run() {
    while (running) { // 工作内存中的副本
        // 看不到 running 被改为 false
    }
}

public void stop() {
    running = false; // 修改主内存，但工作内存可能没更新
}

有序性

有序性指程序执行的顺序按照代码的先后顺序执行。但在多线程或优化环境下，指令可能被重排序。

重排序原因：

• 编译器优化重排序
• 处理器指令级并行重排序
• 内存系统重排序

private int x = 0;
private boolean flag = false;

// 线程 1 执行
public void writer() {
    x = 42; // 1
    flag = true; // 2 可能被重排到 1 之前！
}

// 线程 2 执行
public void reader() {
    if (flag) { // 3
        System.out.println(x); // 可能输出 0 而不是 42！
    }
}

Happens-Before 规则

规则介绍

Happens-Before 是 JMM 的核心概念，它定义了两个操作之间的偏序关系：

• 如果操作 A happens-before 操作 B
• 那么 A 的所有写操作对 B 的读操作都是可见的

有点难看懂？我们用一个简单的例子就能快速理解：

// 核心：happens-before ≠ 时间先后
int x = 0;
int y = 0;

// 时间上：先执行 1，后执行 2
x = 1; // 1
y = x + 1; // 2

// 逻辑上：1 happens-before 2
// 所以 2 一定能看到 1 写入的值

A happens-before B 翻译过来就是：A 对 B 可见。

六大 Happens-Before 规则

1. 程序次序规则：线程内，按照程序代码顺序，前面的操作 happens-before 后面的操作。
2. 监视器锁规则：对一个锁的解锁操作 happens-before 后续对这个锁的加锁操作。
3. volatile 变量规则：对一个 volatile 变量的写操作 happens-before 后续对这个变量的读操作。
4. 线程启动规则：Thread 对象的 start() 方法调用 happens-before 该线程的每一个动作。
5. 线程终止规则：线程中的所有操作 happens-before 其他线程检测到该线程已经终止。
6. 传递性规则：如果 A happens-before B，且 B happens-before C，那么 A happens-before C。

volatile 关键字

volatile 是一个重要的关键字，用于告知编译器某个变量的值可能会被程序外部的因素意外修改，从而避免编译器对该变量进行优化。它的主要作用是确保每次访问变量时都从内存中读取最新的值，而不是使用寄存器中的缓存值。

volatile 提供了两大保证：

• 可见性：修改立即对所有线程可见
• 有序性：禁止指令重排序

private volatile boolean flag = false;
private int count = 0;

public void writer() {
    count = 42; // 普通写操作
    flag = true; // volatile 写操作
}

public void reader() {
    if (flag) { // volatile 读操作
        // 这里一定能看到 count=42
        System.out.println(count);
    }
}

JMM 的常见误区

volatile 无法保证原子性

volatile 可以保证可见性和有序性，但和 synchronized 不一样，不能保证原子性。

// 错误：以为 volatile 能保证原子性
volatile int count = 0;
count++; // 非原子操作

// 正确：使用原子类或同步
AtomicInteger atomicCount = new AtomicInteger(0);
atomicCount.incrementAndGet();

指令重排序的陷阱

// 可能由于重排序导致问题
int a = 0;
boolean flag = false;

// 线程 1
a = 1; // 1
flag = true; // 2 可能重排到 1 之前

// 线程 2
if (flag) {
    System.out.println(a); // 可能输出 0
}

此时我们需要对 flag 使用 volatile 关键字修饰即可，保证在 a 赋值后再执行 flag=true 操作。