Volatile：Java 并发编程中的轻量级同步利器

在 Java 并发编程中，数据竞争与线程安全问题常常让人头疼。Volatile作为 Java 语言中的关键关键字，看似简单，实则蕴含强大功能。它如同双刃剑，既能巧妙化解部分并发难题，也存在使用局限。接下来，我们将深入剖析Volatile的作用与原理。

一、Volatile 如何保证可见性

根据 Java 内存模型（JMM）规范，volatile修饰符具备原子性可见性语义保障机制。在多线程环境下，当某一线程对volatile变量执行写操作时，JMM 会触发store-store与store-load内存屏障，强制将当前线程工作内存中的最新变量值立即同步至主内存；与此同时，该写操作会通过总线嗅探机制（Bus Snooping）使其他线程缓存中对应的volatile变量副本失效。后续其他线程在执行读操作时，必须遵循load-load与load-store内存屏障约束，直接从主内存获取最新的变量值，从而确保多线程环境下的可见性一致性。

内存屏障在可见性保障中发挥重要作用。写屏障（Write Barrier）确保在volatile变量写入前，所有前置变量的写入操作都已提交到主内存；读屏障（Read Barrier）则保证读取volatile变量后，后续所有读操作都从主内存获取数据，就像为volatile变量操作设置了安全关卡。

public class VolatileVisibilityExample {

    // 使用volatile修饰ready变量，确保其可见性
    private static volatile boolean ready;
    private static int num;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            // 当ready为false时，线程t1循环等待
            while (!ready) {
                Thread.yield();
            }
            // 输出num + num的结果
            System.out.println(num + num);
        });

        t1.start();
        num = 2;
        ready = true;
    }
}
 

在上述代码中，ready被声明为volatile变量。主线程将ready置为true后，线程t1能及时感知变化，跳出循环并正确输出结果。若ready未被volatile修饰，线程t1可能因无法及时获取最新值而陷入无限循环，出现可见性问题。

二、Volatile 如何保证内存有序性

Volatile的有序性基于 Java 内存模型（JMM）的happens-before原则，其中规定对volatile变量的写操作happens-before后续读操作，确保读操作获取最新值，维护操作执行顺序。例如，在一个经典的双重检查锁定（Double-Checked Locking）单例模式中，若不将单例实例声明为volatile，在多线程环境下，由于指令重排序，可能出现其他线程获取到未完全初始化的实例，从而引发程序错误。而volatile的有序性保障，能够有效避免此类问题，确保单例模式的正确实现。 注：后续会讲着重讲下JMM

内存屏障是 JMM 实现有序性的关键。写volatile变量时，JVM 插入StoreStore和StoreLoad屏障，前者同步刷新写操作前的普通写操作到主内存，后者禁止指令重排序；读volatile变量时，插入LoadLoad和LoadStore屏障，分别确保前置读操作完成、防止后置写操作重排序，从而构建完整的指令约束体系。

public class VolatileOrderExample {

    private static int a, b;
    
    // 使用volatile修饰flag变量，确保内存可见性和有序性
    private static volatile boolean flag;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            a = 1;
            b = 2;
            flag = true;  // 设置flag为true，通知t2继续执行
        });

        Thread t2 = new Thread(() -> {
            // 等待flag变为true
            while (!flag) {
                Thread.yield();  // 让出CPU时间片
            }
            // 输出a和b的值
            System.out.println(a + " " + b);
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}
 

在此例中，若flag未被volatile修饰，编译器和处理器可能对线程t1中的操作重排序，导致线程t2读取到未初始化的a和b值。而flag被volatile修饰后，线程t2能确保获取到a和b正确赋值后的结果。

三、Volatile 的局限性与线程安全问题

尽管Volatile在可见性和有序性上表现优异，但它无法保证引用对象内部状态的线程安全，根源在于Volatile不能保证对象操作的原子性。例如，对于包含多个成员变量的对象，即便对象引用被声明为volatile，多线程环境下对成员变量的修改仍可能出现数据竞争。

以count++自增操作为例，虽然count可被volatile修饰，但count++在字节码层面由getstatic（获取变量值）、iconst_1（将常量 1 压入操作数栈）、iadd（执行加法运算）、putstatic（将结果写回变量）等一系列操作组成，多线程同时执行时，极易出现数据竞争，导致最终结果错误。

public class VolatileAtomicityExample {

    // 使用volatile修饰count变量，但无法保证count++的原子性
    private static volatile int count = 0;

    public static void increment() {
        count++;
    }

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[100];

        // 创建并启动100个线程
        for (int i = 0; i < 100; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    increment();
                }
            });
            threads[i].start();
        }

        // 等待所有线程执行完毕
        for (Thread thread : threads) {
            thread.join();
        }

        // 输出最终结果
        System.out.println(count);
    }
}
 

上述代码中，尽管count是volatile变量，但由于count++不具备原子性，多个线程并发执行increment方法后，最终的count值会小于预期的100000。

解决此类问题，需借助synchronized关键字或ReentrantLock等锁机制。synchronized关键字确保同一时刻只有一个线程进入同步代码块，保证操作原子性；ReentrantLock则提供更灵活的可重入、可中断、公平锁等特性，适用于复杂并发场景。此外，使用AtomicInteger类的incrementAndGet原子操作方法，也能有效保证多线程环境下结果的正确性。

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicityFixedExample {

    // 使用 AtomicInteger 确保操作的原子性
    private static AtomicInteger count = new AtomicInteger(0);

    public static void increment() {
        count.incrementAndGet();
    }

    public static void main(String[] args) throws InterruptedException {
        // 创建 100 个线程
        Thread[] threads = new Thread[100];

        // 初始化并启动线程
        for (int i = 0; i < 100; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    increment();
                }
            });
            threads[i].start();
        }

        // 等待所有线程执行完毕
        for (Thread thread : threads) {
            thread.join();
        }

        // 输出最终计数结果
        System.out.println(count);
    }
}
 

四、博主总结

• Volatile（怎么解决JMM数据竞争？）
  • 保证可见性？
    • 当写一个 volatile 变量时，JMM 会把该线程在本地内存中的变量强制刷新到主内存中去；
    • 这个写操作会导致其他线程中的 volatile 变量缓存无效。
  • 怎么实现保证可见性的？（插入内存屏障）
    • 写屏障（Write Barrier）：当一个 volatile 变量被写入时，写屏障确保在该屏障之前的所有变量的写入操作都提交到主内存。
    • 读屏障（Read Barrier）：当读取一个 volatile 变量时，读屏障确保在该屏障之后的所有读操作都从主内存中读取。
    • “也就是说，执行到 volatile 变量时，其前面的所有语句都必须执行完，后面所有得语句都未执行。且前面语句的结果对 volatile 变量及其后面语句可见。”
    • 如图所示。

      

    • 图示描述。
    • 线程 t1：先将 num 设为 2，然后将 ready 设置为 true。
    • 线程 t2：在 ready 为 true 时读取 num 的值。
    • 过程：通过使用 volatile 关键字，确保 t2 能实时读取到 ready 的最新状态，以及 num 的最新值，从而避免数据不一致的情况。
  • 怎么保证内存有序性？（禁止指令重排序）
    • volatile 会禁止指令重排序，这个过程建立在 happens before 关系的基础上
    • 指令交错问题（其实是不存在的，因为读操作在写操作之前本来就应该读取旧值，我所说的问题是说不会将要写入的值，对整个程序立即有效）

      

  • volatile 并不能保证引用对象内部状态的线程安全。因为不能保证对象操作的原子性，所以不能保证线程安全。需要使用 synchronized 或 ReentrantLock 等锁机制解决