Java-指令重排

指令重排（Instruction Reordering）是指编译器或者处理器在不改变程序语义的前提下，重新安排指令的执行顺序，以优化性能或者满足硬件的执行特性。在多线程环境中，指令重排可能导致线程安全性问题，因为重排序可能改变原本按照程序顺序应该执行的操作次序。

单线程-可提高程序性能

在实际编程中，一般情况下我们不会故意去使用指令重排来提高性能，因为这可能导致程序出现难以预测和调试的问题。指令重排通常由编译器和硬件在保持程序语义不变的前提下进行优化。

然而，可以提供一个理论上可能利用指令重排来提高性能的示例。假设有以下的代码：

public class ReorderExample {
    private static int x = 0;
    private static boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        Thread writerThread = new Thread(() -> {
            x = 42;
            flag = true;
        });

        Thread readerThread = new Thread(() -> {
            if (flag) {
                System.out.println("x: " + x);
            }
        });

        writerThread.start();
        readerThread.start();

        writerThread.join();
        readerThread.join();
    }
}

在上述代码中，写入线程修改了 x​ 和 flag​ 两个变量，而读取线程在检查 flag​ 为 true​ 后打印 x​ 的值。在正常情况下，由于线程的交错执行，输出应该是 x: 42​。

然而，如果发生了指令重排，可能出现以下的情况：

1. 写入线程重排了写入操作，先执行 flag = true​；
2. 读取线程在检查 flag​ 为 true​ 后，输出 x​ 的值，此时 x​ 还没有被写入。

这样的重排可能导致输出为空，而不是预期的 x: 42​。然而，这种情况只是一个理论上的可能性，实际上并不鼓励使用这样的代码来尝试指令重排。在正常的应用程序中，我们更注重代码的可读性、可维护性和正确性，而不是依赖于指令重排来提高性能。

多线程-指令重排会破坏程序的正确性

Java中的指令重排问题通常与JVM和编译器有关。为了提高性能，JVM和编译器可能会对代码进行优化，包括指令重排。然而，在多线程环境中，这可能会破坏程序的正确性。

例子：

考虑以下的双重检查锁定（Double-Checked Locking）例子：

class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance <span style="font-weight: bold;" class="mark"> null) {      // 1. 第一次检查
            synchronized (Singleton.class) {
                if (instance </span> null) {  // 2. 第二次检查
                    instance = new Singleton();  // 3. 创建对象
                }
            }
        }
        return instance;  // 4. 返回对象引用
    }
}

在这个例子中，看起来是一个常见的双重检查锁定模式，但是在多线程环境下，由于指令重排，可能会导致问题。

如果指令重排发生，可能的执行顺序为：

1. 线程1：检查 instance​ 不为null，进入同步块。
2. 线程2：由于线程1还未完成创建对象，instance​ 仍为null，进入同步块。
3. 线程2：创建对象。
4. 线程2：将 instance​ 指向新创建的对象。
5. 线程1：从同步块中退出，返回 instance​，但此时 instance​ 指向的对象可能还未完全初始化。

避免指令重排：

为了避免指令重排，可以使用volatile​关键字。在上述例子中，private static volatile Singleton instance;​ 中的 volatile​ 就是用来禁止指令重排的。

​volatile​ 修饰的变量具有两个特性：

1. 禁止指令重排。
2. 强制将修改的值立即写入主内存，使得其他线程可以立即看到修改。

通过在 instance​ 上使用 volatile​，可以确保在对象引用被初始化后，其他线程能够正确地看到初始化的值。这是因为 volatile​ 关键字保证了在写入 instance​ 时，不会发生指令重排，从而保证了对象的安全发布。

‍