Java中volatile关键字实现可见性的原理与演示

许南星

发布时间：2026-10-16 | 6人浏览过

原创

Java中的volatile关键字是轻量级的同步机制，主要解决多线程环境下的可见性问题。其核心原理是利用CPU的缓存一致性协议（如MESI）和总线嗅探机制，确保变量修改后能立即刷新到主内存并无效化其他核心的缓存，从而保证所有线程读取到的都是最新值。

volatile实现可见性的底层原理

当使用volatile修饰共享变量时，编译器会为其生成特定的汇编指令。在写操作中，通常会插入Lock前缀指令（如x86架构下的lock addl），这一操作在多核处理器环境中触发两个关键行为：

写回系统内存：将当前处理器缓存行中的数据强制写回主内存。
使其他缓存失效：该写回操作会广播消息，导致其他CPU核心中缓存了该地址的数据变为无效状态。

理解CPU缓存一致性与MESI协议

在多核环境下，每个CPU核心拥有自己的高速缓存（Cache），直接修改缓存数据会导致各核心间数据不一致。为了解决这个问题，硬件层面引入了缓存一致性协议，其中最典型的是Intel的MESI协议：

M (Modified) 已修改：数据已修改，仅存在于当前缓存，与主内存不同步。
E (Exclusive) 独占：数据仅在当前缓存，且与主内存一致。
S (Shared) 共享：数据在当前缓存，也可能在其他缓存中，且都与主内存一致。
I (Invalidated) 已失效：数据无效，必须从主内存或其他缓存重新加载。

总线嗅探技术是维护一致性的关键。当某个核心修改数据时，它会在总线上广播“我修改了这块地址”的信号。其他所有核心都会监听这个信号，如果发现与自己缓存中的数据地址匹配，就会将该缓存行的状态标记为I (Invalid)。下次当其他核心需要读取该数据时，由于发现缓存失效，便会强制从主内存中重新加载最新数据。

volatile可见性代码演示

为了直观展示volatile的作用，我们可以通过对比测试来观察线程间共享变量的可见性差异。以下代码模拟了一个读取线程和一个写入线程不断操作同一个整型变量flag。

第1步：未使用volatile时的表现

在没有volatile修饰的情况下，JVM允许优化器将flag的值缓存在读取线程的工作栈或寄存器中。即使写入线程修改了flag，读取线程可能因为无法感知主内存的变化而陷入死循环。

public class VolatileDemo {
    static int flag = 1; // 普通共享变量

    public static void main(String[] args) {
        // 线程1：负责读取flag
        new Thread() {
            @Override
            public void run() {
                int localFlag = flag;
                while (true) {
                    if (localFlag != flag) {
                        System.out.println("读到了flag修改后的值：" + flag);
                        localFlag = flag;
                    }
                }
            }
        }.start();

        // 线程2：负责修改flag
        new Thread() {
            @Override
            public void run() {
                int localFlag = flag;
                while (true) {
                    try {
                        Thread.sleep(1000); // 每秒修改一次
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("对flag的值进行修改:" + ++localFlag);
                    flag = localFlag;
                }
            }
        }.start();
    }
}

运行上述代码可以发现，读取线程往往输出极少或者无输出，因为它一直使用本地缓存的初始值1，无法及时发现flag的变化。

第2步：使用volatile后的表现

只需在flag声明处增加volatile关键字，即可强制每次访问都从主内存读取，并将修改立即写回主内存。

public class VolatileDemo {
    static volatile int flag = 1; // 添加volatile关键字

    public static void main(String[] args) {
        // ... 线程逻辑同上 ...
        new Thread() {
            @Override
            public void run() {
                int localFlag = flag;
                while (true) {
                    if (localFlag != flag) {
                        System.out.println("读到了flag修改后的值：" + flag);
                        localFlag = flag;
                    }
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                int localFlag = flag;
                while (true) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("对flag的值进行修改:" + ++localFlag);
                    flag = localFlag;
                }
            }
        }.start();
    }
}