什么是 Java 中的指令重排？

晚夜微雨问海棠呀

203人浏览 · 2026-03-14 09:24:02

晚夜微雨问海棠呀 · 2026-03-14 09:24:02 发布

Java 中的指令重排

🎯 什么是指令重排？

指令重排是指编译器和处理器为了优化程序性能，在不改变单线程执行结果的前提下，改变指令执行顺序的一种优化手段。

📝 通俗解释

想象你在做早餐：

// 原始代码顺序
1. 烧水
2. 烤面包
3. 煮鸡蛋
4. 倒牛奶

实际执行可能变成：

// 重排后的顺序
1. 烧水（需要等待）
2. 烤面包（同时进行）
3. 倒牛奶（快速完成）
4. 煮鸡蛋（水开后）

虽然顺序变了，但最终结果一样：你吃到了早餐！

🔧 为什么需要指令重排？

1. 提高性能

int a = 1;    // 指令1
int b = 2;    // 指令2
int c = a + b; // 指令3

可能重排为：

int b = 2;    // 先执行
int a = 1;    // 后执行
int c = a + b; // 结果不变

2. 利用流水线

// 原始顺序
load a from memory  // 慢
calculate a + 1
store result

// 重排后（如果后面有不依赖的指令）
load b from memory  // 先加载其他数据
load a from memory  // 并行加载
calculate a + 1
calculate b + 1

⚠️ 重排的规则

✅ 允许的重排

int a = 1;
int b = 2;
// 这两行可以交换顺序，互不影响

❌ 不允许的重排（依赖关系）

int a = 1;
int b = a + 2;  // 依赖 a，不能重排到前面

🚨 重排带来的问题

经典案例：单例模式的双重检查锁

public class Singleton {
    private static Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {              // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) {      // 第二次检查
                    instance = new Singleton(); // 创建对象
                }
            }
        }
        return instance;
    }
}

问题所在：new Singleton() 实际分为三步：

1. 分配内存空间
2. 初始化对象（调用构造方法）
3. 将引用指向分配的内存

可能的重排：

1. 分配内存空间
3. 将引用指向分配的内存  ← 先指向了
2. 初始化对象           ← 还没初始化

后果：

线程A：执行到步骤3，instance 不为 null 了，但对象还没初始化
线程B：第一次检查发现 instance != null，直接返回了未初始化的对象！

🔧 解决方案：使用 volatile

public class Singleton {
    private static volatile Singleton instance;  // 加上 volatile
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

volatile 的作用：

禁止指令重排
保证可见性

📊 更多重排示例

示例1：看似无关的代码

int x = 1;
int y = 2;
// 可能重排为：
int y = 2;
int x = 1;

示例2：有依赖关系

int a = 10;
int b = a + 5;
int c = b * 2;
// 不能重排，因为有数据依赖

示例3：多线程问题

// 线程1
data = 100;    // 写入数据
ready = true;  // 标记就绪

// 线程2
if (ready) {   // 检查就绪
    System.out.println(data);  // 读取数据
}

可能的重排：

// 线程1中可能重排为
ready = true;  // 先标记就绪
data = 100;    // 后写入数据

// 线程2可能读到 ready=true 但 data 还是旧值！

🛡️ 如何避免重排问题？

1. 使用 volatile 关键字

private volatile boolean ready;
private volatile int data;

2. 使用 synchronized

synchronized (lock) {
    data = 100;
    ready = true;
}

3. 使用 final 字段

public class FinalExample {
    private final int x;
    private final int y;
    
    public FinalExample() {
        x = 1;
        y = 2;
    }
    // final 字段保证初始化安全性
}

4. 使用 Atomic 类

AtomicInteger data = new AtomicInteger();
AtomicBoolean ready = new AtomicBoolean();

5. 使用锁机制

ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    data = 100;
    ready = true;
} finally {
    lock.unlock();
}

💡 Happens-Before 原则

Java 内存模型定义了一些规则，保证某些操作不会被重排：

规则	说明
程序次序规则	单线程内，代码顺序执行
volatile 规则	volatile 写 happens-before volatile 读
锁规则	解锁 happens-before 加锁
传递性	A happens-before B，B happens-before C，则 A happens-before C
线程启动规则	Thread.start() happens-before 线程执行
线程终止规则	线程终止 happens-before Thread.join() 返回