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() 时,可见性沿着下面这条链传递:
- 写线程先初始化
next指向的对象,再调用publish,依次执行data = next和ready = true。 - 读线程在
readIfReady()中读到ready == true,这次 volatile 读和写线程对ready的写之间建立了 happens-before 关系。 - 读线程接着读取
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. 参考资料
- JLS 8.3.1.4:
volatileFields - JLS 17.4.5:Happens-before Order
- Java API:
VarHandle - JLS 17.7:Non-Atomic Treatment of double and long
- Java 21 API:AtomicIntegerArray
来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明