跳到主要内容
约 9 分钟3 张卡

volatile

volatile 是修饰字段的关键字,为线程间的字段读写提供可见性和顺序保证,适合停止标志、配置替换这类「写一个值、别人读到就行」的场景。它不保证读线程在固定时间内获得调度,也不把多次读写合成一个原子操作:递增、先检查再更新、几个字段一起变化,都不能只靠它保证正确。理解 volatile,要分清它保证了什么、没保证什么,以及怎样借它把普通数据安全地交给别的线程。

1. 面试核心​

先记住这几条,再读正文
  • 对同一 volatile 字段的写,与同步顺序中后续对它的读建立 happens-before 关系,线程之间因此能可靠地交接状态。
  • volatile 保证单次读写的原子性,但 count++ 的读取、加一和写回仍可被其他线程穿插,精确递增需要原子类或锁。卡 · volatile 读写的顺序保证
  • 发布者先写数据、再写 volatile 标志,读者先读到这次写入的标志、再读数据,才能看到发布前的普通写入。
  • 把数组引用声明为 volatile,约束的只是引用的读写,元素的并发修改仍需单独同步;整组数据可以通过只读快照发布。卡 · 引用与数组元素
  • 停止标志和不可变配置适合用 volatile;检查并更新、多个字段共同保持一致,需要原子操作、锁或整体发布。
  • VarHandle 中,opaque 只约束同一变量的访问顺序,acquire/release 可以配对发布关联数据,volatile 模式还要求所有 volatile 访问满足共同的总序。卡 · VarHandle 的访问模式

2. volatile 读写的顺序保证​

最典型的用法是让一个线程通知另一个线程停止工作。停止标志声明为 volatile,工作线程每处理一轮就重新检查一次:

private volatile boolean closed;

public void close() {
closed = true;
}

public void runLoop() {
while (!closed) {
processOne();
}
}

如果 closed 是普通字段,JIT 编译器可以认为循环里没人修改它,把读取提到循环外面只读一次,工作线程就永远看不到 true。声明为 volatile 后,每次检查都必须真正读取这个字段;关闭线程写入 closed = true 之后,工作线程在后续某次检查中读到新值,退出循环。

背后的规则来自 Java 内存模型(JMM):对同一个 volatile 字段的写,happens-before 同步顺序中在它之后对这个字段的读。JVM 仍然可以做编译优化和指令重排,但执行结果必须满足这条保证。具体的传递规则见 Java 内存模型。

注意标志要等工作线程下一次检查时才生效。如果 processOne() 长时间阻塞,还需要中断、关闭资源这类取消机制,让当前这一轮及时结束。

3. 复合更新​

volatile 字段的一次读和一次写各自是原子的,但连在一起不是一个原子操作。最常见的例子是递增:

private volatile int count;

public void increment() {
count++;
}

count++ 要先读出旧值,再加一,最后写回。两个线程都读到 10,各自写回 11,两次递增只留下一次。volatile 读遵守该字段在同步顺序中的写入顺序,但挡不住另一个线程在「读」和「写」之间插进来。精确计数可以用 AtomicInteger.incrementAndGet(),或者用锁保护整个递增。

先检查后执行也有同样的问题。下面的标志即使声明为 volatile,也不能保证初始化只执行一次:

private volatile boolean initialized;

void initializeOnce() {
if (!initialized) {
initialize();
initialized = true;
}
}

多个线程可能同时读到 false,然后各自进入 initialize()。只允许初始化一次的话,要用锁把检查和初始化包在一起,或者设计一个包含初始化过程的原子状态转换。

4. volatile 标志发布​

volatile 的可见性保证不只覆盖这个字段本身,还能捎带它之前的普通写入。利用这一点,可以用一个 volatile 标志把普通字段安全地交给另一个线程。下面的示例中,publish 只调用一次,之后不再修改 data 指向的对象:

private Data data;
private volatile boolean ready;

void publish(Data next) {
data = next;
ready = true;
}

Data readIfReady() {
if (ready) {
return data;
}
return null;
}

假设调用 publish 之前,写线程已经初始化好了 next 指向的对象。另一个线程调用 readIfReady() 时,可见性沿着下面这条链传递:

  1. 写线程先初始化 next 指向的对象,再调用 publish,依次执行 data = next 和 ready = true。
  2. 读线程在 readIfReady() 中读到 ready == true,这次 volatile 读和写线程对 ready 的写之间建立了 happens-before 关系。
  3. 读线程接着读取 data,就能看到 data = next 的结果,以及写线程在此之前对这个对象的初始化。

所以 data 可以只是普通字段,前提是两边的顺序都对:写线程先赋值 data、再写 ready;读线程先读到 ready == true、再读 data。如果写线程把两行顺序反过来,或者读线程先读 data 再检查 ready,又或者检查的是另一个标志,这条链就断了,读线程可能拿到 null 或者初始化不完整的对象。

这个写法只适合发布一次。如果多次调用 publish,ready 第一次之后就一直是 true,读线程看到 true 也分不清 data 是哪一次调用写的。它可能依据较早的 ready 写入通过检查,却读到尚未通过本次 ready 写入安全发布的新对象;这个对象的普通字段初始化就缺少所需的可见性保证。

需要反复更新配置时,换一种做法:每次把新配置做成一个不可变对象,再替换一个 volatile 引用。读者只读一次这个引用,拿着这份快照完成整次操作,用到的所有字段就来自同一个版本。

5. 内存屏障​

内存屏障是一类约束读写顺序的指令或编译器约束,保证屏障前后的某些访问不会被重排。JVM 用它们在不同处理器上实现 Java 的内存语义:JIT 编译器把 volatile 和 VarHandle 的访问,映射成编译器层面的约束、对应的机器指令,以及需要的屏障。

描述屏障时,Load 表示读,Store 表示写。四种名称分别说明维持哪两类访问的先后:

屏障类型约束的访问顺序
LoadLoad屏障前的读与屏障后的读
LoadStore屏障前的读与屏障后的写
StoreStore屏障前的写与屏障后的写
StoreLoad屏障前的写与屏障后的读

这些名称描述的是顺序约束本身。实际用哪条机器指令、哪些屏障可以省略、执行成本多高,取决于处理器架构和 JIT 实现。比如 x86 本身已经保证了大部分顺序,通常只有 StoreLoad 需要额外的指令。

所以判断 Java 代码是否正确,应该依据 JMM 和访问模式,而不是某张 x86 屏障表;换一个架构,屏障表就不同了,JMM 的保证却不变。只有在优化底层组件时,才需要结合目标架构测量屏障和缓存竞争的成本。

6. 使用场景​

用不用 volatile,先看要维护的是一个可以独立读写的值,还是必须一起完成的多个变化。常见需求可以按下表选择:

需求选择边界
停止标志volatile 布尔值工作循环需重新检查
不可变配置volatile 引用发布后保持内容不变
精确计数原子类需要原子读改写
检查并扣减CAS 或锁条件与更新共同生效
多字段快照不可变对象加发布协议单次读取取得同一版本

停止标志和不可变配置只需要单独读写或整体替换,正好落在 volatile 的保证范围内。只有一个线程写的状态机有时也可以用 volatile,因为不存在两个写者互相覆盖,但要先确认每次状态转换都符合业务要求。多个字段各自声明为 volatile,读者仍可能看到新旧值混在一起的状态,这时要整体发布或者加锁。

7. 引用与数组元素​

对数组来说,先要分清替换引用和修改元素是两件事。数组引用声明为 volatile 后,把整个引用换成另一个数组具有 volatile 语义;但执行 values[0] = 1,只是先读一次 volatile 引用、再对元素做一次普通写入,元素本身没有 volatile 语义。

需要对单个元素做原子操作时,用 AtomicIntegerArray。要求整组数据一致时,就创建一个新数组,再发布它的引用,并且已发布的数组不再修改:

private volatile int[] values = {0, 0};

void publish() {
values = new int[] {1, 2};
}

int readSum() {
int[] snapshot = values;
return snapshot[0] + snapshot[1];
}

已发布的数组不再变化,readSum() 又只读一次共享引用,存进局部变量 snapshot,所以两个元素一定来自同一个数组,求和结果只可能是 0 或 3。如果写成 values[0] + values[1],两次读取之间引用可能被替换,就会出现 0 + 2 这样新旧混合的结果。

8. VarHandle 的访问模式​

VarHandle 是访问字段或数组元素的句柄,可以在每次访问时指定读写的内存语义。它从 Java 9 开始提供,按强度从弱到强有四种模式:

模式保证重点
plain:get / set按普通字段的语义读写
opaque:getOpaque / setOpaque保证单次读写的原子性和同一变量的相干顺序
acquire / release:getAcquire / setRelease配对交接时约束周围访问的顺序
volatile:getVolatile / setVolatile在 acquire/release 基础上增加 volatile 总序约束

表中的相干顺序,是指所有线程对同一个变量的访问遵守一致的先后次序。它只针对这一个变量,所以单独使用 opaque,无法保证其他关联数据也被正确发布。

acquire/release 解决的正是关联数据的问题。setRelease 保证它之前的读写不会被移到它之后;读到这次写入值的 getAcquire,保证它之后的读写不会被移到它之前。两者配对,效果和第 4 节的标志发布一样:写者在 release 之前写好的数据,读者在 acquire 之后都能看到。volatile 模式在此基础上,还要求所有 volatile 访问排成一个所有线程都认同的总顺序。

降低访问模式的强度可以省掉一些屏障,但每降一级,都要重新证明关联数据仍然可见。普通业务代码直接用 volatile 字段或成熟的 java.util.concurrent 组件就够了。

9. 常见问题​

9.1 volatile long 只是为了防止读写撕裂吗?​

不只是。防止撕裂是其中一项,volatile 同时还提供可见性和顺序保证。JLS 允许普通 long 和 double 的读写拆成两次 32 位操作,读者可能读到一次写入的高 32 位和另一次写入的低 32 位,这就是撕裂。volatile long 和 volatile double 的单次读写保证是原子的,不会出现这种结果。

9.2 多个字段都加 volatile,就能保持状态一致吗?​

10. 面试题卡片​

11. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明