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

解密Java内存模型：从happens-before原则到实战可见性问题

article 2025/3/28 22:38:06

《解密Java内存模型：从happens-before原则到实战可见性问题》

一、为什么需要Java内存模型？

1.1 现代计算机的存储体系

1.2 多线程环境下三大核心问题

可见性问题：线程A修改的变量，线程B无法立即看到
原子性问题：非原子操作被线程切换打断
有序性问题：编译器/处理器优化导致的指令重排序

二、JMM抽象模型图解

2.1 JMM核心结构

2.2 内存间交互八大原子操作

操作	作用
lock（锁定）	将主内存变量标识为线程独占状态
unlock（解锁）	释放被锁定的变量
read（读取）	从主内存传输变量到工作内存
load（载入）	将read得到的值放入工作内存副本
use（使用）	将变量值传递给执行引擎
assign（赋值）	将执行引擎接收的值赋给变量
store（存储）	将工作内存变量传送到主内存
write（写入）	将store得到的值放入主内存变量

三、happens-before原则全解析

3.1 原则定义
如果操作A happens-before 操作B，那么A的执行结果对B可见，且A的执行顺序排在B之前

3.2 八大规则详解

规则1：程序顺序规则

int x = 10;         // 操作A
int y = x + 1;      // 操作B
// 同一个线程中，A happens-before B

规则2：管程锁定规则

synchronized (lock) { // 加锁
    x = 20;           // 操作A
}                     // 解锁
// 解锁happens-before后续加锁操作

规则3：volatile变量规则

volatile boolean flag = false;

// 线程1
flag = true;         // 写操作

// 线程2
if (flag) {          // 读操作
    // 能看到线程1的写入
}

规则4：线程启动规则

Thread t = new Thread(() -> {
    // 此处能看到主线程在start()之前的所有修改
});
t.start();  // start() happens-before run()

规则5：线程终止规则

t.join(); 
// 子线程中的所有操作happens-before主线程的join返回

规则6：中断规则

// 线程A
threadB.interrupt();

// 线程B
if (Thread.interrupted()) {
    // 能看到A的中断操作
}

规则7：对象终结规则

// 对象构造函数执行happens-before finalize()方法

规则8：传递性规则

// 若A happens-before B，B happens-before C
// 则A happens-before C

四、可见性问题实战分析

4.1 典型可见性故障

public class VisibilityDemo {
    // 不加volatile会导致死循环
    private static /*volatile*/ boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (flag) {
                // 空循环
            }
            System.out.println("子线程结束");
        }).start();

        Thread.sleep(2000);
        flag = false; // 主线程修改
        System.out.println("主线程修改完成");
    }
}
// 输出结果可能永远无法打印"子线程结束"

4.2 volatile解决方案

private static volatile boolean flag = true; 
// 写入操作会立即刷新到主内存
// 读取操作会从主内存重新加载

4.3 synchronized解决方案

public class SynchronizedSolution {
    private static boolean flag = true;
    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (true) {
                synchronized (lock) {
                    if (!flag) break;
                }
            }
            System.out.println("子线程结束");
        }).start();

        Thread.sleep(2000);
        synchronized (lock) {
            flag = false;
        }
        System.out.println("主线程修改完成");
    }
}
// 通过锁的happens-before关系保证可见性

五、指令重排序验证实验

5.1 重排序可能导致的诡异结果

public class ReorderingDemo {
    private static int x = 0, y = 0;
    private static int a = 0, b = 0;

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; ; i++) {
            x = y = a = b = 0;
            
            Thread t1 = new Thread(() -> {
                a = 1;  // 操作1
                x = b;  // 操作2
            });
            
            Thread t2 = new Thread(() -> {
                b = 1;  // 操作3
                y = a;  // 操作4
            });
            
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            
            if (x == 0 && y == 0) {
                System.out.println("第" + i + "次出现(x=0,y=0)");
                break;
            }
        }
    }
}
// 实际运行可能输出出现(x=0,y=0)的情况

5.2 禁止重排序的解决方案

// 方案1：使用volatile修饰变量
private volatile static int x = 0, y = 0;

// 方案2：增加同步块
synchronized (lock) {
    a = 1;
    x = b;
}

六、JMM最佳实践指南

6.1 线程安全的三层保障

可见性：volatile/synchronized/final
原子性：Atomic类/synchronized
有序性：happens-before规则

6.2 并发工具选择策略

6.3 内存屏障类型对照表

屏障类型	作用	对应Java操作
LoadLoad屏障	禁止读-读重排序	volatile读
StoreStore屏障	禁止写-写重排序	volatile写
LoadStore屏障	禁止读-写重排序	无直接对应
StoreLoad屏障	禁止所有重排序（全能型屏障）	volatile变量访问