volatile 是 Java 中用于保证多线程可见性和禁止指令重排序的轻量级同步关键字，相比 synchronized 更轻量（无锁竞争、无上下文切换开销），但也有明确的使用边界。本文从底层原理、核心用法、实战场景到源码应用，全方位拆解 volatile，帮你彻底搞懂它的适用场景和坑点。

一、volatile 核心定义

volatile（易变的）是 Java 的变量修饰符，仅能修饰成员变量（实例 / 静态），核心作用是：

1. 可见性：一个线程修改了 volatile 变量的值，其他线程能立即看到最新值（解决多线程间 “缓存不一致” 问题）；
2. 禁止指令重排序：阻止 JVM 和 CPU 对 volatile 变量相关的指令进行重排序优化（解决 “有序性” 问题）；
3. 不保证原子性：这是 volatile 最易踩坑的点，它无法替代锁实现复合操作的原子性。

设计初衷：在不使用重量级锁（如 synchronized）的前提下，解决多线程中变量的 “可见性” 和 “有序性” 问题，提升并发性能。

二、volatile 解决的核心问题

要理解 volatile，先搞懂多线程下普通变量的两个核心问题：

2.1 可见性问题（普通变量的坑）

Java 内存模型（JMM）中，每个线程有自己的工作内存（缓存），普通变量的修改会先写入工作内存，再异步刷新到主内存。这导致：线程 A 修改了变量值，线程 B 可能读取到的还是旧值（缓存未同步）。

普通变量可见性问题演示：

public class VisibilityProblem {
    // 普通变量：无volatile修饰
    private boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        VisibilityProblem demo = new VisibilityProblem();

        // 线程1：等待flag变为true后停止
        new Thread(() -> {
            while (!demo.flag) {
                // 空循环：线程1一直读取工作内存中的flag（旧值false）
            }
            System.out.println("线程1停止");
        }).start();

        // 主线程：1秒后修改flag为true
        Thread.sleep(1000);
        demo.flag = true;
        System.out.println("主线程已将flag设为true");

        // 现象：线程1永远不会停止，因为看不到主线程修改的flag值
    }
}

2.2 指令重排序问题（普通变量的坑）

JVM 和 CPU 为了提升性能，会对无依赖的指令进行重排序（如 “先赋值后初始化” 可能被重排为 “先初始化后赋值”）。在多线程下，重排序可能导致逻辑错乱（典型场景：单例模式的双重检查锁）。

2.3 volatile 如何解决这两个问题？

• 可见性：volatile 变量的修改会立即刷新到主内存，且其他线程读取时会直接从主内存加载（跳过工作内存），保证变量值 “实时同步”；
• 有序性：volatile 会在变量读写前后插入 “内存屏障”，阻止指令重排序（如写屏障保证 volatile 写之前的指令不会被重排到之后，读屏障保证 volatile 读之后的指令不会被重排到之前）。

三、volatile 核心用法与示例

3.1 解决可见性问题（修复上面的示例）

public class VolatileVisibility {
    // volatile修饰：保证可见性
    private volatile boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        VolatileVisibility demo = new VolatileVisibility();

        // 线程1：能立即看到flag的修改
        new Thread(() -> {
            while (!demo.flag) {
                // 空循环：当flag变为true时，线程1会立即感知
            }
            System.out.println("线程1停止");
        }).start();

        // 主线程：1秒后修改flag
        Thread.sleep(1000);
        demo.flag = true;
        System.out.println("主线程已将flag设为true");

        // 现象：线程1会立即停止，因为能看到最新的flag值
    }
}

3.2 解决指令重排序问题（单例模式双重检查锁）

这是 volatile 最经典的实战场景，先看有问题的双重检查锁：

// 有问题的单例：指令重排序导致多线程下可能获取到未初始化的对象
class Singleton {
    private static Singleton instance; // 无volatile

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (Singleton.class) { // 加锁
                if (instance == null) { // 第二次检查
                    instance = new Singleton(); // 指令重排序风险！
                }
            }
        }
        return instance;
    }
}

问题根源：instance = new Singleton() 实际分 3 步执行：

1. 分配内存空间；
2. 初始化对象；
3. 将 instance 指向分配的内存地址。

JVM 可能将步骤 2 和 3 重排序（1→3→2），导致线程 A 执行到 3 但未执行 2 时，线程 B 第一次检查看到 instance 不为 null，直接返回一个 “半初始化” 的对象。

volatile 修复版：

// 正确的双重检查锁单例：volatile禁止指令重排序
class Singleton {
    // volatile修饰：禁止指令重排序
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton(); // 不会重排序
                }
            }
        }
        return instance;
    }
}

3.3 volatile 不保证原子性（核心坑点）

volatile 仅能保证单次读 / 写的可见性，无法保证复合操作（如 i++）的原子性。

反例演示：

public class VolatileAtomicProblem {
    private volatile int count = 0;

    public void increment() {
        count++; // 复合操作：读→加1→写，非原子性
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileAtomicProblem demo = new VolatileAtomicProblem();

        // 10个线程，每个线程执行1000次count++
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    demo.increment();
                }
            }).start();
        }

        // 等待所有线程执行完毕
        Thread.sleep(2000);
        // 预期值：10*1000=10000，实际值远小于10000
        System.out.println("count最终值：" + demo.count);
    }
}

原因：count++ 是 3 个独立操作，volatile 只能保证每个操作的可见性，但无法保证 3 个操作的原子性（比如线程 A 读 count=10，线程 B 也读 count=10，都加 1 后写回，最终 count=11 而非 12）。

解决方案：

• 使用 AtomicInteger（原子类，底层 CAS）；
• 使用 synchronized 或 Lock 加锁；
• 避免在 volatile 变量上做复合操作。

四、volatile 在 JDK 源码中的应用

4.1 java.util.concurrent.atomic 包（原子类）

AtomicInteger、AtomicLong 等原子类的核心字段 value 被 volatile 修饰，保证多线程下的可见性：

public class AtomicInteger extends Number implements java.io.Serializable {
    // volatile修饰：保证value的可见性
    private volatile int value;

    public final int get() {
        return value;
    }

    // CAS操作：保证原子性
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
}

4.2 java.util.concurrent.locks.LockSupport

LockSupport 的 parkBlocker 字段（存储线程阻塞原因）被 volatile 修饰，保证线程间的可见性：

public class LockSupport {
    private static final sun.misc.Unsafe UNSAFE;
    // volatile修饰：保证阻塞原因的可见性
    private static volatile long parkBlockerOffset;
    
    // ... 其他代码
}

4.3 Thread 类的中断标志

Thread 类的 interrupted 状态（中断标志）相关字段被 volatile 修饰，保证线程能立即感知中断：

public class Thread implements Runnable {
    // volatile修饰：中断标志
    private volatile boolean interrupted = false;

    public boolean isInterrupted() {
        return interrupted;
    }

    public void interrupt() {
        interrupted = true;
        // ... 唤醒线程
    }
}

五、volatile vs synchronized：核心区别

表格

特性	volatile	synchronized
修饰范围	仅能修饰成员变量（实例 / 静态）	可修饰方法、代码块
原子性	不保证（仅单次读写）	保证（复合操作也原子）
可见性	保证	保证
有序性	保证（禁止指令重排序）	保证（锁释放时刷新主内存）
性能	轻量级（无锁，几乎无性能损耗）	重量级（有锁竞争、上下文切换）
使用场景	单变量的读 / 写、禁止重排序	复合操作、临界区代码

六、volatile 适用场景总结

6.1 适用场景

1. 状态标记位：多线程间的开关 / 标志（如停止线程的 flag）；
2. 单例模式双重检查锁：禁止指令重排序，避免半初始化对象；
3. 与 CAS 结合：如原子类（AtomicInteger），volatile 保证可见性，CAS 保证原子性；
4. 多线程下的单次读写变量：如配置参数、计数统计（非复合操作）。

6.2 不适用场景

1. 复合操作：如 i++、i -= 1 等（需用原子类或锁）；
2. 需要互斥访问：如多线程修改同一个集合（需用 ConcurrentHashMap 或锁）；
3. 依赖前值的操作：如if (count > 0) { count--; }（需保证判断和修改的原子性）。

七、常见面试题 & 易错点

7.1 面试高频问题

1. volatile 能保证原子性吗？不能。volatile 仅保证单次读 / 写的可见性和有序性，复合操作（如 i++）仍会有线程安全问题，需结合 CAS 或锁。
2. volatile 解决了什么问题？解决多线程下的可见性和有序性问题，不解决原子性问题。
3. 双重检查锁单例为什么要加 volatile？禁止instance = new Singleton()的指令重排序，避免多线程下获取到 “半初始化” 的对象。

7.2 开发易错点

1. 误用 volatile 保证原子性：以为 volatile 修饰的 i++ 是线程安全的；
2. 修饰局部变量：volatile 仅能修饰成员变量，修饰局部变量会编译报错；
3. 忽略 volatile 的有序性作用：仅知道可见性，不知道能解决指令重排序问题。

总结

1. volatile 核心作用是保证可见性、禁止指令重排序，但不保证原子性；
2. 适用场景：状态标记位、单例双重检查锁、与 CAS 结合的原子类；
3. 核心边界：volatile 是轻量级同步方案，无法替代锁解决复合操作的线程安全问题。

volatile 是 Java 并发编程的基础关键字，掌握它的原理和适用场景，能帮你写出更高效、更安全的并发代码。