知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 54 - volatile 关键字与内存可见性 > 导读:本文从"明明改了标志位,子线程为什么看不到"这个现象出发,把 volatile 保证的可见性与有序性、内存屏障的插入位置、它与 happens-before 的对应关系讲透,再用停止标记、双重检查锁、计数器三个真实例子说明它的边界。适合想搞懂 JMM 底层、以及正在准备后端面试的同学。 ## 一、先建立全局认知 ### Q:volatile 到底保证了哪几件事? A:结论先行——volatile 保证**两件事**,并且只保证这两件:**可见性**和**禁止指令重排序(有序性)**;它**不保证原子性**。 - **可见性**(visibility):一个线程修改了 volatile 变量,新值会立刻被其他线程看到,不会被闷在本地缓存里。 - **有序性**(ordering):编译器和 CPU 不得把 volatile 变量前后的指令随意重排到它的另一侧,从而禁止了特定类型的指令重排序。 - **不保证原子性**:像 `count++` 这种"读—改—写"的复合操作,volatile 拦不住中间被打断,多线程下照样丢更新。 一句话记忆:**volatile 管的是"看得到"和"不乱序",不管"不被打断"。** ### Q:volatile 与 JMM 是什么关系? A:JMM(Java 内存模型)是一套抽象规范,它规定了一个线程的写何时对另一个线程可见、哪些重排序被允许。JMM 为程序员准备了一套 happens-before 规则,volatile 规则只是其中一条;而内存屏障是 JVM 为了让这些规则落地而使用的实现手段。换句话说:**JMM 定义"应该看到什么",happens-before 是给人看的规则,内存屏障是给机器看的指令**。理清这个层次,就不会把"volatile 保证可见性"和"插了哪些屏障"混为一谈。 ### Q:为什么 volatile 不能替代锁? A:因为**锁保证的是互斥(原子性),volatile 根本不提供互斥**。 锁通过"同一时刻只有一个线程能进入临界区"来保证复合操作的整体不可分割;volatile 只承诺"每次读都拿最新值、每次写都立刻发布",它不会阻塞任何线程,也就无法阻止两个线程同时读到同一个旧值、各自加一、再各自写回——这就是典型的**丢失更新**。所以判断标准很清晰:**只做单一变量的读或写、且不需要"基于旧值算新值"**,才可能用 volatile 替代锁。 ## 二、理解核心机制 ### Q:volatile 的可见性在 JVM 与硬件两个层面分别是怎么做到的? A:分两层看,语义层和实现层。 - **JVM 语义层**:volatile 写会把该变量**立刻刷回主内存**;volatile 读会**强制从主内存重新读取**,并让本线程对应的本地缓存副本失效。 - **硬件实现层**:底层的做法是在 volatile 写之后插入一条带 **lock 前缀**的指令(如 `lock addl $0, (%rsp)`),它会触发缓存行写回主内存,并借助**缓存一致性协议(MESI,一种多核间同步缓存行状态的协议)**让其他核心对应的缓存行失效。 这里要给一个重要的提醒:**lock 前缀和 MESI 只是硬件层面的"实现手段",不是 volatile 语义本身。** volatile 的可见性与有序性是由 JMM(Java 内存模型,规范 Java 并发行为的一套抽象规则)定义的;不同 CPU 架构的落地方式并不相同(x86 与 ARM 就有差异),把它们和 volatile 语义直接画等号,是常见的八股误区。  *图:volatile 写的刷出路径与 volatile 读写两侧插入的内存屏障——写前 StoreStore、写后 StoreLoad、读后 LoadLoad/LoadStore。* ### Q:内存屏障是怎么插入的?四种屏障分别解决什么重排序? A:JMM 用四种屏障(Memory Barrier / Memory Fence)来约束重排序,插入位置是固定的: - **volatile 写**:在写操作**之前**插入 **StoreStore**,在写操作**之后**插入 **StoreLoad**; - **volatile 读**:在读操作**之后**插入 **LoadLoad** 和 **LoadStore**。 四种屏障各自解决的问题: 1. **StoreStore(写前)**:禁止上面的普通写被重排到 volatile 写之后,保证 volatile 写执行时,它前面所有普通写都已刷出。 2. **StoreLoad(写后)**:禁止 volatile 写与后面的 volatile 读写重排,通常还要把写缓冲刷出。它是开销最大、也最关键的一道,x86 上一般用 `mfence` 实现。 3. **LoadLoad(读后)**:禁止上面的 volatile 读与后面的普通读重排。 4. **LoadStore(读后)**:禁止上面的 volatile 读与后面的普通写重排。 一张表记住插入点:**写的前后是 StoreStore / StoreLoad,读的后侧是 LoadLoad / LoadStore**。 ### Q:volatile 与 happens-before 是什么关系? A:happens-before 是 JMM 定义"可见性是否成立"的抽象规则。volatile 对应的规则非常直接:**对一个 volatile 变量的写,happens-before 于后续对它的读。** 这条规则的意义在于:它把"写线程在 volatile 写之前的**所有**操作"都变成了对"读线程在 volatile 读之后的**所有**操作"可见。也就是说,volatile 变量像一道"可见性闸门"——闸门之前的普通写,都会随着这次 volatile 写一起,被后续读到的线程看到。这也解释了下面 DCL 和停止标记为什么成立。 ### Q:从字节码看,volatile 为什么保证不了原子性? A:因为 `count++` 在字节码层面就是**多条指令**:读字段、压栈、加一、写回字段。volatile 只是在这些读写的前后插入了屏障,**并没有把这几条指令合并成一个不可分割的整体**。两个线程完全可能交错成"都读到 0 → 都算出 1 → 都写回 1",屏障拦不住这种交错。要真正原子,要么用 CAS 把"比较 + 交换"做成一条 CPU 指令,要么用锁把整个临界区圈起来——这正是原子类比 volatile 多出来的能力。 ### Q:volatile 修饰数组或对象引用时,保证范围到哪里? A:只保证**引用本身**的可见性,不保证数组元素或对象字段。比如 `volatile int[] arr`,`arr = new int[10]` 这个引用赋值是可见的,但 `arr[0] = 1`、`obj.field = 2` 这些元素/字段的读写并不被 volatile 保护。需要连内容一起保证时,得改用 `AtomicIntegerArray` 之类的原子类,或对整体加锁。 ### Q:volatile 修饰 long / double 有什么特别? A:JMM 规定,**volatile 的 long 和 double 读写必须是原子的**。这一条在 32 位 JVM 上尤其有意义:普通(非 volatile)的 long / double 位宽超过 32 位,历史上允许被拆成两次 32 位访问,极端情况下可能读到一个"高 32 位是旧值、低 32 位是新值"的撕裂值;而 volatile 从规范层面要求按整体读写,杜绝了这种多位撕裂。这也是它在某些平台上相对更"重"的原因之一。 ## 三、放进真实场景 ### Q:状态标志位(停止标记)为什么必须加 volatile? A:先看失败版。下面的任务本该在主线程置 `stop = true` 后退出,但子线程可能**永远看不到**这个改动,一直空转: ```java public class StopFlagBug { private static boolean stop = false; // 缺少 volatile public static void main(String[] args) throws InterruptedException { new Thread(() -> { while (!stop) { // 可能一直读到 false,永远不退出 // do work } System.out.println("worker stopped"); }).start(); Thread.sleep(1000); stop = true; // 子线程可能观察不到 } } ``` 原因是子线程把 `stop` 读进了本地缓存,主线程的修改没有可靠地同步给它。修正只需一个关键字: ```java private static volatile boolean stop = false; // volatile 保证写立刻可见、读最新值 ``` 关键点:这里**每个线程只做单个变量的读写、不依赖旧值计算**,正好落在 volatile 的能力范围内,所以一个 volatile 就够,不必上锁。 ### Q:DCL 单例里 volatile 为什么不可省? A:因为 `new` 不是原子动作,它分三步:分配内存、初始化对象、把引用指向内存。没有 volatile 时,编译器和 CPU 可能把"指向内存"重排到"初始化"之前,于是别的线程可能拿到一个**引用非空但对象尚未初始化完成**的半成品。 ```java public class Singleton { // volatile 禁止 new 的三步重排序,防止其他线程看到半初始化对象 private static volatile Singleton instance; public static Singleton getInstance() { if (instance == null) { // 第一次检查:不加锁,走快路径 synchronized (Singleton.class) { if (instance == null) { // 第二次检查:防止重复创建 instance = new Singleton(); // volatile 写,保证构造完成后再发布 } } } return instance; } } ``` 关键点:DCL 靠两道检查减少加锁,但**真正兜底的是 volatile**——它保证 `instance` 被看到时,对象一定构造完毕。少了它,DCL 在某些情况下会返回半初始化对象,是经典隐患。 ### Q:i++ / count++ 为什么不安全?该换成什么? A:因为 `count++` 是"读—改—写"三步,volatile 只保证每步看到最新值,却挡不住两个线程同时读到同一个值: ```java public class CounterBug { private volatile int count = 0; public void increment() { count++; // 非原子:读、加一、写回,中间可能被其它线程插入 } } ``` 1000 个线程各加一次,结果往往小于 1000。修正方向有两个: - **`AtomicInteger`**:用 CAS(比较并交换)保证"读—改—写"整体原子,适合并发不高的计数; - **`LongAdder`**:把热点拆成多个单元格分散竞争,最后求和,**高并发下吞吐更好**(这是 JDK 8 引入的类)。 结论:**复合操作要的是原子性,这恰恰是 volatile 给不了的,必须换成原子类或加锁。** ### Q:volatile 与 synchronized 怎么选?它适合什么边界? A:按"需要什么"来选: - **只要可见性、且是单一变量读写** → volatile,开销小、不加锁; - **需要原子性、或多变量要保持一致** → synchronized(或 `ReentrantLock`)。 volatile 最典型的适用边界是**"一写多读"**:一个线程写、多个线程读同一标志或配置。一旦出现"多个写者"或"读后要基于结果计算再写",volatile 就不够了。另外要提醒:volatile 也不提供互斥,`volatile` 与 `synchronized` 不是"谁替代谁"的关系,而是**解决不同问题**。 ### Q:为什么"一写多读"会成为一个安全边界? A:因为这种模式下不存在两个线程同时"基于旧值算新值"的竞争:唯一的写者按自己的节奏发布新值,其他线程只负责读取最新值,可见性一旦成立,结果就是确定的。但只要突破两条中的任意一条——出现第二个写者,或者读线程要"读了再改"——竞争就回来了,volatile 立刻失效。所以判断 volatile 能不能用,问自己两句话即可:**"是不是只有一个写者?" "读了之后还要不要再写?"** ### Q:volatile 最容易踩的误区有哪些? A:三个高频误区: 1. **以为 volatile 等于线程安全**:它只管可见性与有序性,`count++` 这类复合操作照样出错,必须叠加原子类或锁。 2. **以为 volatile 能保护数组元素或对象字段**:它只保证引用本身的可见性,`arr[i]`、`obj.field` 不在保护范围内。 3. **想用一个 volatile 变量去"同步"一整组普通变量**:volatile 写确实能让它之前的普通写一并可见,但一旦是多写者各自更新不同变量,仍然需要锁来保证一致性,单靠一个 volatile 撑不住。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:建议按"保证什么 → 怎么实现 → 用在哪"三段来答: 1. **保证什么**:volatile 保证可见性与有序性,不保证原子性;因此不能替代锁。 2. **怎么实现**:写立刻刷主内存、读强制回主内存并让本地缓存失效;写前 StoreStore、写后 StoreLoad,读后 LoadLoad、LoadStore;与 happens-before 的对应是"对 volatile 变量的写 happens-before 后续对它的读";硬件上靠 lock 前缀与 MESI,但那只是实现手段。 3. **用在哪**:状态标志、"一写多读"、DCL 防重排序;`count++` 这类复合操作要换 `AtomicInteger` / `LongAdder`。 ### Q:如果面试官追问"volatile 算不算线程安全"? A:要分场景回答,不能一刀切。对**单一变量的读写、且不依赖旧值**,volatile 是线程安全的;对**复合操作或多变量协同**,volatile 不构成线程安全,必须叠加锁或原子类。这个回答体现的是"先看操作类型、再下结论",而不是背一句"volatile 保证可见性不保证原子性"。 ### Q:答这道题时最容易丢分的地方在哪? A:最常见的是"只背结论、不问前提":一上来就说"volatile 保证可见性不保证原子性",却不解释**可见性是怎么落地的**(屏障与 happens-before),也说不清**什么场景下 volatile 才够用**。第二常见的是把实现当语义,把"lock 前缀 / MESI"直接说成 volatile 的定义。把"语义 → 规则 → 实现"这三层分开讲,才是真正的加分项。 --- ## 自测 1. volatile 保证哪两件事、不保证哪一件事?为什么它不能替代锁? 2. volatile 写和 volatile 读分别插入哪些内存屏障?StoreLoad 为什么开销最大? 3. "对 volatile 变量的写 happens-before 后续对它的读"这条规则,为什么能保证写之前的所有普通操作也可见? 4. DCL 单例中 volatile 不可省的原因是什么?`volatile int` 上的 `count++` 为什么仍然不安全?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入