结论先行:volatile 只保证两件事——可见性(写立即对其他线程可见)和有序性(禁止指令重排),不保证原子性。volatile int i; i++ 依然是线程不安全的。把这条边界记牢,volatile 相关的线上问题九成能直接定位。

可见性问题的根源

Java 内存模型允许每个线程把共享变量缓存在自己的工作内存(对应 CPU 缓存与寄存器),一个线程改了变量,另一个线程可能一直在读旧值。volatile 变量在写操作时通过内存屏障强制把值刷出,并让其他 CPU 核上对应的缓存行失效;读操作则强制加载最新值。效果是:volatile 写之后,任何后续读都能看到这个值。最典型的踩坑形态是「循环等标志位」:

public class StopFlagDemo {
    // 错误写法:缺 volatile,工作线程可能永远读不到 true
    private static boolean stop = false;

    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            while (!stop) {
                // JIT 可能把 stop 的读取提升到循环外:
                // 相当于 while (true),死循环无法退出
            }
            System.out.println("stopped");
        }).start();
        Thread.sleep(1000);
        stop = true;   // 主线程写入,另一个线程可能感知不到
    }
}

// 正确写法:只改一行,保证写之后的所有读可见
private static volatile boolean stop = false;

不加 volatile 时这段代码在多数环境会「永远停不下来」:编译器发现循环体内没人修改 stop,把读取优化到循环外。volatile 禁掉这个优化,每次都从主存重新加载。

有序性:写一读二,中间不能乱

JSR-133 定义的 happens-before 规则中与 volatile 相关的一条:对 volatile 变量的写操作 happens-before 后续对该变量的读操作。编译器和 CPU 为了优化会重排指令,volatile 通过在读写前后插入内存屏障来禁止特定方向的重排序。最经典的落地场景是双重检查锁定(DCL)单例:

public class Singleton {
    // volatile 禁止「赋引用」与「初始化对象」被重排
    private static volatile Singleton instance;

    public static Singleton getInstance() {
        if (instance == null) {                  // 第一次检查,无锁
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();  // 关键行
                }
            }
        }
        return instance;
    }
}

instance 不加 volatile 是 DCL 的经典 bug:new Singleton() 在字节码层面分为三步——分配内存、初始化对象、把引用赋给 instance,其中后两步可能被重排成「先赋引用、再初始化」。另一个线程在第一次检查时拿到非 null 的引用,返回了一个还没执行完构造器的半成品对象。volatile 禁止这个重排,问题消失。值得记住的是顺序语义的另一面:volatile 写之前的操作不会被重排到写之后,volatile 读之后的操作不会被重排到读之前——这构成了「写线程在写标志前完成的所有准备工作,读线程在看到标志后都看得见」的传递保证,多变量配合发布数据时很有用。

顺带给出 DCL 的两个替代品,避免手写这层细节:静态内部类 holder 写法依赖类初始化锁保证线程安全;枚举单例由 JVM 保证唯一并防反射攻击。工程上优先用这两者,volatile 版 DCL 更多出现在面试和遗留代码里——能读懂它的正确性,比能手写它更重要。

原子性为什么不在保证范围内

i++ 实际是「读 i、加 1、写回」三步。两个线程同时读到同一个值,各自加 1 后写回,结果丢了一次自增。volatile 保证每一步都看到最新值,但挡不住三步之间被其他线程穿插。需要原子自增用 AtomicInteger(CAS)或 LongAdder(高并发计数);需要多变量一起原子更新就加锁:

// 错误写法:volatile 救不了复合操作,多线程统计必然丢计数
private static volatile int count = 0;
void handle() {
    count++;   // 读-加-写三步,中间可被穿插
}

// 正确写法一:计数场景用原子类,CAS 保证单操作原子
private static final AtomicInteger COUNT = new AtomicInteger();
void handle() { COUNT.incrementAndGet(); }

// 正确写法二:并发更高时用 LongAdder,分段降低 CAS 竞争
private static final LongAdder ADDER = new LongAdder();
void handle() { ADDER.increment(); }

还有一个组合用法值得记住:volatile + CAS。AtomicInteger 内部就是把 volatile 保证可见性、CAS 保证原子性两件事拼在一起。自己写无锁代码时同理——volatile 变量配合 compareAndSet 语义的原子操作才能构成完整的并发协议,单靠 volatile 不够。

实现机制:内存屏障

编译器在 volatile 字段读写前后插入不同类型的内存屏障(LoadLoad、StoreStore、LoadStore、StoreLoad 四类),硬件层面它们对应不同架构的具体指令:x86 本身是强内存序,大部分重排本来就不允许,volatile 的额外成本主要是一次 StoreLoad;ARM 等弱内存序架构上屏障更密集。这也是「volatile 开销小但不是零」的原因:它阻止优化、强制刷新缓存,比普通读写贵,但远比加锁便宜。理解成本模型才能做对取舍——能用 volatile 解决的问题没必要上锁,反过来也一样。

推理并发正确性时,happens-before 是比「屏障」更高层的工具:除了 volatile 的写读配对,还有程序顺序规则、锁的解锁加锁配对、线程 start/join 配对。判断一段并发代码是否安全,沿 happens-before 传递链推理,比逐条记屏障方向可靠得多。

使用场景与工具选择

volatile 的正确用法是「一写多读」的状态标志:配置开关、任务终止标志、DCL 单例。判断标准很朴素——变量的新值不依赖它自己的旧值(flag = true 可以,count++ 不行),且不需要和其他变量保持联合不变量。满足这两条,volatile 就是比锁轻得多的选择;不满足,老老实实加锁。常用并发工具的能力边界用一张表对齐:

工具原子性可见性有序性典型场景
volatile不保证保证禁止特定重排一写多读的状态标志
synchronized保证保证保证复合操作、多变量不变量
AtomicInteger单操作保证保证不涉及计数、累加、CAS 判断
LongAdder单操作保证保证(求和弱一致)不涉及高并发统计上报

反例清单也值得背下来:volatile 数组——元素的可见性不受保证,要用原子数组或字段更新器;volatile 引用指向可变对象——对象内部字段的修改不经过 volatile 语义;以及所有复合判断(检查再设置)。这三类误用都能编译通过、单线程测试正常,直到线上并发才暴露。

补一个 Java 9+ 的工具视角:变量句柄(VarHandle)提供了比 volatile 更细粒度的访问模式(plain/opaque/acquire/release/volatile),同类问题在底层库里有更精确的表达。业务代码继续用 volatile 字段即可,读第三方并发库源码时认识这套分级就行。

验证手段也有现成工具:jcstress 是 OpenJDK 官方的并发正确性压测框架,验证某段代码是否真有可见性问题、修复是否有效,比肉眼推理可靠得多。

生产案例

某次线上告警,一个灰度开关「推了但不生效」:配置中心把某功能的降级开关置为 true,网关侧日志确认收到了变更并调用了 setter,但部分节点上的业务线程始终按旧值走。排查发现开关字段是普通 boolean,业务线程在一个高频循环里轮询它,JIT 把字段读取提升到了循环外——工作线程眼里这个值永远是方法进入时的快照。同一个集群里负载低、循环没被深度优化的节点表现正常,问题因此只出现在部分节点,更增加了迷惑性。修复只是一行:字段加 volatile。这个案例值得记住的不是那一行代码,而是「可见性问题是概率性的、与编译器优化和硬件相关」这个特征——同类问题在测试环境可能复现不出来,评审时对「一写多读的标志位」逐一确认 volatile 修饰,成本远低于线上排查。