有了 MESI 协议，为什么还要 volatile?

1. MESI 协议：CPU 缓存一致性

MESI 协议是一种广泛用于多核处理器的缓存一致性协议，它的名字来源于四种缓存行状态：M (Modified)、E (Exclusive)、S (Shared) 和 I (Invalid)。MESI 协议的主要作用是确保多个 CPU 核心之间的缓存数据保持一致。

• M (Modified)：缓存行被修改过，数据只存在于当前核心的缓存中，且与主内存不同步。

• E (Exclusive)：缓存行未被修改，数据只存在于当前核心的缓存中，且与主内存同步。

• S (Shared)：缓存行未被修改，数据可能存在于多个核心的缓存中，且与主内存同步。

• I (Invalid)：缓存行无效，数据不可用。

MESI 协议通过监听总线上的缓存操作，确保当一个核心修改了某个缓存行时，其他核心的对应缓存行会被标记为无效（Invalid），从而保证缓存一致性。

2. Java 中的 volatile：线程缓存一致性

尽管 MESI 协议在硬件层面解决了 CPU 缓存一致性问题，但 Java 程序运行在 JVM 上，JVM 有自己的内存模型（JMM），用于解决多线程环境下的内存可见性和一致性问题。volatile 是 Java 中用于确保变量可见性和有序性的关键字。

为什么需要 volatile？

1. Store Buffer 的影响：

   • 现代 CPU 通常会使用 Store Buffer（存储缓冲区）来优化写操作。当一个线程写入一个变量时，数据可能先被写入 Store Buffer，而不是直接写入 L1 缓存。这可能导致其他线程看不到最新的变量值。

   • volatile 的底层实现通过 lock 指令（在 x86 架构中）确保变量的写操作直接写入主内存，从而忽略 Store Buffer 的影响，保证变量的可见性。

2. 缓存行失效：

   • volatile 的写操作不仅会将变量写入主内存，还会通过 lock 指令使其他核心的缓存行失效。这样，其他线程在读取该变量时，会直接从主内存中读取最新的值，而不是从本地缓存中读取旧值。

3. volatile 的实现机制

在 x86 架构中，volatile 的实现依赖于 lock 指令。lock 指令的作用是：

• 确保原子性：确保对变量的读写操作是原子的。

• 内存屏障：防止指令重排序，确保对变量的读写操作不会被编译器或 CPU 重排序。

• 缓存一致性：通过使其他核心的缓存行失效，确保所有线程都能看到最新的变量值。

4. 示例代码

示例 1：没有使用 volatile 的问题

public class NoVolatileExample {
    private static boolean ready = false;

    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            while (!ready) {
                // 线程一直在等待 ready 变为 true
            }
            System.out.println("Worker thread started.");
        });

        worker.start();

        Thread.sleep(1000);
        ready = true; // 主线程设置 ready 为 true
        System.out.println("Main thread set ready to "+ready);
    }
}

在这个例子中，worker 线程可能永远看不到 ready 被设置为 true，因为它可能一直在使用本地缓存中的旧值。

示例 2：使用 volatile 解决问题

public class VolatileExample {
    private static volatile boolean ready = false;

    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            while (!ready) {
                // 线程一直在等待 ready 变为 true
            }
            System.out.println("Worker thread started.");
        });

        worker.start();

        Thread.sleep(1000);
        ready = true; // 主线程设置 ready 为 true
        System.out.println("Main thread set ready to "+ready);
    }
}

在这个例子中，volatile 确保了 ready 的写操作直接写入主内存，并使其他线程的缓存失效。因此，worker 线程能够立即看到 ready 被设置为 true。

5. 总结

• MESI 协议：在硬件层面解决了 CPU 缓存一致性问题，确保多个 CPU 核心之间的缓存数据保持一致。

• volatile 关键字：在 Java 层面解决了线程之间的缓存一致性问题，确保变量的可见性和有序性。

• Store Buffer 的影响：volatile 的写操作通过 lock 指令确保变量直接写入主内存，忽略 Store Buffer 的影响，从而保证变量的可见性。

• 缓存行失效：volatile 的写操作会使其他核心的缓存行失效，确保其他线程能够看到最新的变量值。

通过 volatile，Java 程序能够在多线程环境下实现高效的内存可见性和一致性，而不需要依赖于底层硬件的缓存一致性协议。