JUC-01
JUC Day 2:synchronized、锁优化、volatile、CAS 与原子类
学习目标:理解 Java 如何保证线程安全,能够解释
synchronized
的底层实现、锁状态变化、volatile的语义,以及 CAS/原子类的适用场景。本文按 Day 2 学习范围整理:synchronized → 锁优化 → volatile → CAS
与原子类。其中 JDK 8 经典锁实现与 JDK 21+
新轻量级锁实现分开说明,避免混淆不同版本。
一、先建立整体认识:线程安全靠什么?
学习具体并发工具之前,先建立一套共同的基础概念:共享变量、线程安全、JMM、原子性/可见性/有序性,以及 happens-before。后面学习 synchronized、volatile 和 CAS 时,都会反复用到这些概念。
1.1 共享变量与线程安全问题
多个线程同时访问同一份可变数据时,如果访问顺序不受正确的同步规则约束,就可能出现线程安全问题。
- 共享变量:多个线程都能访问的变量,例如实例字段、静态字段,或通过对象引用共享的数据。
- 临界区:访问共享状态、且需要保证执行约束的一段代码。
- 竞态条件(Race Condition):程序结果取决于多个线程执行时序,而这种时序没有得到正确控制。
- 数据竞争(Data Race):多个线程对同一变量进行冲突访问(至少一个是写),并且这些访问之间没有被 happens-before 关系正确排序。
例如,下面的 count++ 就存在竞态风险:
private int count = 0;
public void increment() {
count++;
}
count++ 至少包含读取、计算、写回几个步骤。多个线程可能同时读到相同的旧值,导致更新丢失。后面会看到:volatile 不能让这个复合操作自动变成原子操作,而 synchronized 或 AtomicInteger 可以提供相应保护。
1.2 线程安全的三个核心特性
并发编程中经常从三个维度分析线程安全:
| 特性 | 要回答的问题 | 典型问题或例子 |
|---|---|---|
| 原子性 | 一个操作是否不可分割? | count++ 可能发生读取、计算、写回之间的交错 |
| 可见性 | 一个线程的写入,其他线程能否按规则观察到? | 线程 A 修改标志位,线程 B 仍可能读到旧值 |
| 有序性 | 编译器和 CPU 的重排序是否会破坏程序要求的顺序? | 先发布引用、后完成对象初始化可能导致不安全发布 |
这三个特性是分析问题的角度,不是三种互斥的工具。一个同步机制可能同时提供其中多种保证:
synchronized:提供互斥,并通过锁释放/获取建立可见性和有序性保证。volatile:提供可见性和有序性,但不保证count++这类复合操作的原子性。- CAS / 原子类:为特定变量更新提供原子条件更新;原子类还结合相应的内存语义。
1.3 Java 内存模型(JMM)是什么?
Java 内存模型(Java Memory Model,JMM)是 Java 语言规范定义的一套并发访问规则。它规定了在多线程环境下,哪些写入必须对哪些读取可见,以及哪些操作之间必须保持怎样的顺序。
初学时常用“主内存”和“工作内存”来帮助理解:线程可能使用自己的工作数据副本,线程间需要通过同步机制协调共享数据。但要注意:JMM 是抽象的语义模型,不是说 JVM 中真的存在一个统一的主内存区域、每个线程也真的有一块物理工作内存。 实际实现可能涉及 CPU 缓存、寄存器、编译器优化和内存屏障等。
学习 JMM,先抓住两个问题:
- 可见性:线程 A 的写入,线程 B 在什么条件下必须能够观察到?
- 有序性:编译器或 CPU 可以进行哪些重排序,哪些重排序会被 JMM 规则禁止?
而判断这些问题时,最重要的基础规则就是 happens-before。
1.4 happens-before:JMM 的基础规则
happens-before(先行发生)是 JMM 用来描述操作之间可见性与顺序约束的规则。若操作 A happens-before 操作 B,那么 JMM 保证:A 的执行结果对 B 可见,并且 A 在语义上先行于 B。
它不等于现实时间上 A 一定比 B 早执行完,也不代表 CPU 必须把所有指令严格按源码顺序执行。只要最终结果符合 JMM 规定,编译器和 CPU 仍然可以进行合法优化。
常见 happens-before 规则
| 规则 | 含义 | 典型例子 |
|---|---|---|
| 程序顺序规则(Program Order) | 同一线程中,按照程序顺序,前面的操作 happens-before 后面的操作 | 同一线程先执行 a = 1,再执行 b = 2 |
| 监视器锁规则(Monitor Lock) | 对同一把锁的 unlock happens-before 后续成功获取这把锁的 lock | T1 退出 synchronized (lock),T2 随后进入同一把锁保护的区域 |
| volatile 变量规则 | 对某个 volatile 变量的写 happens-before 后续对同一变量的读(该读观察到这次写) | T1 写 ready = true,T2 随后读到该值 |
| 线程启动规则(Thread Start) | 对线程调用 start() happens-before 被启动线程中的任意操作 |
主线程先设置配置,再调用 worker.start() |
| 线程终止规则(Thread Termination) | 线程中的操作 happens-before 其他线程检测到该线程已经终止 | 工作线程结束后,主线程 join() 成功返回再读取结果 |
| 线程中断规则(Thread Interruption) | 一个线程调用另一个线程的 interrupt() happens-before 被中断线程检测到中断 |
T1 调用 worker.interrupt(),worker 随后检测到中断 |
| 默认初始化规则(Default Initialization) | 对象的默认初始化先行发生于程序中的其他操作 | 对象字段在可观察到之前先获得 0、false 或 null 等默认值 |
| 传递性(Transitivity) | 若 A happens-before B,且 B happens-before C,则 A happens-before C | 普通变量写 → volatile 写 → volatile 读 → 普通变量读 |
用一个例子理解传递性
// data 是普通变量,ready 是 volatile
// 线程 T1 // 线程 T2
data = 100; if (ready) {
ready = true; // volatile 写 System.out.println(data);
}
当 T2 读到 ready == true 时:
- T1 中
data = 100按程序顺序先于ready = true。 - 对
ready的 volatile 写,与 T2 后续读到该写的 volatile 读建立同步关系。 - T2 中 volatile 读按程序顺序先于读取
data。 - 根据传递性,
data = 100happens-before T2 对data的读取,因此 T2 能看到100。
两个容易混淆的点
- 有 happens-before,才有对应的 JMM 可见性与顺序保证;没有建立 happens-before,不代表结果一定错误,只代表不能依赖这条规则保证结果。
- happens-before 不是禁止一切指令重排。 它约束的是程序可观察到的结果,允许不改变这些结果的合法优化。
- 正确同步的程序具有顺序一致性保证(DRF-SC):如果程序不存在数据竞争,那么它的执行结果可以按某种顺序一致的方式理解。实际开发中,重点是用锁、volatile 等同步机制正确建立线程间关系,而不是依赖线程调度时机。
1.5 把基础规则对应到 Day 2 的工具
| 工具 | 主要解决的问题 | 核心机制 |
|---|---|---|
synchronized |
临界区互斥,并提供可见性、有序性保障 | Monitor / 内置锁;unlock 与后续 lock 建立 happens-before |
volatile |
可见性、有序性 | volatile 读写语义;对同一变量的写与后续读建立 happens-before |
| CAS | 对单个变量进行原子条件更新 | Compare-And-Set |
AtomicInteger 等 |
常见变量的无锁原子更新 | CAS + 相应的内存语义 |
LongAdder |
高并发计数 | 分散竞争到多个计数单元 |
要记住:这些工具不是互相替代的关系。例如 volatile 不能单独保证 i++ 的原子性;CAS 也不自动让多个变量组成的业务操作具备原子性。
二、synchronized
2.1 synchronized 的作用
synchronized 是 Java
内置的互斥同步机制。多个线程竞争同一把锁时,同一时刻最多只有一个线程能够持有该
Monitor 并执行对应的临界区。
它主要提供:
- 互斥性:同一把锁保护的临界区不能被多个线程同时执行。
- 可见性:一个线程释放锁之前对共享变量的修改,对随后成功获取同一把锁的线程可见。
- 有序性:锁的释放与后续获取之间建立 happens-before 关系。
示例:
public class Counter {
private int count;
public synchronized void increment() {
count++;
}
public synchronized int get() {
return count;
}
}
这里的 synchronized 保护的是当前对象 this。如果多个线程操作的是不同
Counter 实例,它们拿到的不是同一把对象锁。
2.2 synchronized 的三种常见写法
同步实例方法
public synchronized void doWork() {
// 锁对象是 this
}
同步静态方法
public static synchronized void doWork() {
// 锁对象是当前类对应的 Class 对象
}
同步代码块
private final Object lock = new Object();
public void doWork() {
synchronized (lock) {
// 锁对象是 lock
}
}
面试常问:实例同步方法与静态同步方法不是同一把锁。前者锁 this,后者锁
类名.class。
2.3 synchronized 的底层:Monitor
每个 Java 对象都可以关联一个用于同步的 Monitor(监视器)。HotSpot
中通常由 ObjectMonitor 等运行时结构实现重量级监视器。
理解几个概念:
| 概念 | 含义 |
|---|---|
| Monitor | 监视器,管理锁的所有权、竞争和等待 |
| Owner | 当前持有 Monitor 的线程 |
EntryList / _cxq |
参与竞争 Monitor 的线程队列结构(具体组织依实现而定) |
| WaitSet | 调用该对象 wait() 后等待通知的线程集合 |
_recursions |
与 Monitor 重入相关的计数信息 |
不要把 EntryList 和 WaitSet 混为一谈:
- EntryList /
_cxq:线程正在竞争锁。 - WaitSet:线程曾经持有锁,调用
wait()
主动释放锁并等待某个条件或通知。 notify()让等待线程有机会重新参与锁竞争,不会直接把锁交给它。
2.4 字节码层面:monitorenter / monitorexit
对于同步代码块,编译后的字节码通常包含:
monitorenter:进入同步区域,尝试获取对象 Monitor。monitorexit:退出同步区域,释放 Monitor。
编译器还需要保证异常退出时也能释放锁,因此会生成相应的异常处理路径。
对于 synchronized
方法,通常不是在方法体中简单插入这两个指令,而是在方法访问标志中设置
ACC_SYNCHRONIZED,由 JVM 在方法调用/返回过程中处理同步语义。
三、对象头、Mark Word 与锁优化
3.1 对象头是什么?
以常见的 64 位 HotSpot 普通对象为例,对象头通常包含:
- Mark Word:记录对象运行时状态信息。
- Klass Pointer:指向对象所属类的元数据。
数组对象还包含数组长度信息。
Mark Word 的空间有限,不同锁状态下会复用其中的位,因此不能理解为
HashCode、锁指针、线程 ID 等信息永远同时存在。
Mark Word 可能涉及的信息包括:
- 对象身份哈希码(identity hash code)
- GC 年龄
- 锁状态标志
- 在特定锁状态下与锁记录或 Monitor 相关的信息
- 某些旧版本实现中的偏向锁相关信息
具体位布局依赖 JVM 实现、版本和配置。不要把某张简化示意图当成所有 JDK
都通用的固定布局。
3.2 JDK 8 经典轻量级锁:Stack Locking
JDK 8 经典 HotSpot 实现采用传统 Stack Locking
思路。为了理解它,记住三个对象:
- 对象自身的 Mark Word。
- 当前线程栈帧中的 Lock Record(HotSpot 实现中涉及
BasicLock)。 - Lock Record 中保存原始 Mark Word 的
_displaced_header。
加锁过程
假设对象最初处于无锁状态:
- 线程准备进入
synchronized。 - 在线程栈帧中准备 Lock Record。
- 将对象原始 Mark Word 复制到 Lock Record 的
_displaced_header中。 - 通过 CAS 尝试把对象 Mark Word 替换为指向 Lock Record 的指针。
- CAS 成功,表示获取轻量级锁成功;失败则进入相应的慢路径处理。
简化示意:
加锁前:
对象 Mark Word = 原始 Mark Word
线程栈:
Lock Record(准备中)
加锁后:
对象 Mark Word = 指向 Lock Record 的指针
线程栈:
Lock Record
└── displaced_header = 原始 Mark Word
为什么要保存原始 Mark Word?
因为旧版实现会用 Lock Record 地址替换对象原来的 Mark
Word。原来的对象头信息被覆盖了,解锁时需要有地方恢复它。
解锁过程
- 线程读取 Lock Record 中保存的原始 Mark Word。
- 通过 CAS 尝试把对象 Mark Word 从 Lock Record 指针恢复成原始 Mark
Word。 - CAS 成功,完成快速解锁。
- 如果 CAS
失败,说明对象锁状态可能已经变化,例如发生了锁膨胀,需要走慢路径。
关键记忆:旧版轻量级锁 = 栈上 Lock Record 保存 Displaced Mark Word +
CAS 替换/恢复对象 Mark Word。
3.3 新版轻量级锁:Lightweight Locking / Lock Stack
新轻量级锁机制在 JDK 21 引入,JDK 23 起默认启用。它与 JDK 8 经典 Stack
Locking 不是同一套实现。
新版思路:
- 对象处于可加锁状态时,线程通过 CAS 更新 Mark Word 中的锁状态。
- 不再采用”把对象头替换成线程栈中 Lock Record 地址”的传统方式。
- 当前线程通过自己的 Lock Stack 记录持有轻量级锁的对象引用。
- 解锁时结合对象头状态和线程的 Lock Stack 完成释放。
简化理解:
对象 Mark Word:
原有对象头信息 + 锁状态位
线程 Lock Stack:
记录当前线程持有的对象引用
为什么新版不需要传统的 Displaced Mark Word?
因为新版轻量级加锁不再用 Lock Record 地址整体替换对象的 Mark Word。
旧版需要保存原始 Mark
Word,是因为原始内容被覆盖;新版保留原有对象头信息,只更新锁状态,因此不需要采用旧版那种”先保存完整原值、解锁时再恢复”的模式。
注意:
- “不需要传统 Displaced Mark Word”不等于”新版完全不需要对象头状态变化”。
- 新版仍然需要通过对象头状态和线程本地 Lock Stack
协同完成加锁、解锁与竞争处理。 - 不要把 JDK 8 的 Lock Record 指针模型直接套到 JDK 25 上。
3.4 JDK 8 与新版轻量级锁对比
| 对比项 | JDK 8 经典 Stack Locking | 新版 Lightweight Locking |
|---|---|---|
| 线程侧记录 | 栈帧中的 Lock Record | 线程本地 Lock Stack |
| 线程侧记录内容 | 保存 Displaced Mark Word | 记录持锁对象引用 |
| 对象头加锁方式 | Mark Word 替换为 Lock Record 地址 | 更新锁状态,不采用传统栈地址替换模式 |
| 解锁思路 | CAS 恢复原始 Mark Word | 结合锁状态和 Lock Stack 释放 |
| 是否需要传统 Displaced Mark Word | 需要 | 不需要 |
3.5 锁膨胀是什么意思?
锁膨胀(Lock
Inflation)指轻量级锁等快速路径无法继续满足竞争处理需求时,JVM
将对象关联到重量级 Monitor,由 Monitor 管理锁所有权和竞争线程。
简化理解:
轻量级锁快速路径
|
| 竞争/慢路径处理
v
关联 ObjectMonitor
|
v
由 Monitor 管理 Owner、竞争队列和 WaitSet
要注意:
- 不是”只要第二个线程来竞争,就必然立即膨胀”。
- 膨胀的具体触发和处理路径依 JDK 版本、锁状态和运行时策略而定。
- 重量级 Monitor
可能涉及线程阻塞与唤醒,但具体竞争过程不应简化成”所有竞争线程立即挂起”。 - 锁膨胀后,不代表每次解锁都会立即恢复成轻量级锁。
Monitor Deflation
HotSpot 有 Monitor
Deflation(监视器膨胀回收)机制,可以在合适条件和时机回收不再使用的
Monitor。
必须区分:
- Unlock:释放当前线程对 Monitor 的所有权。
- Deflation:回收不再使用的 Monitor 结构。
Deflation
不是每次解锁后立刻执行的”锁降级”,也不意味着每个对象都会马上恢复到轻量级锁状态。
3.6 JDK 8 偏向锁需要怎么理解?
JDK 8 的经典锁优化讨论中经常会提到:
- 偏向锁:倾向于让同一线程重复进入同步块时减少同步开销。
- 轻量级锁:通过 CAS 等快速路径处理低竞争场景。
- 重量级锁:通过 Monitor 管理竞争和等待。
但这不是每次 synchronized 都必然经历的固定流水线。偏向锁的启用还受到
JDK 版本和 JVM 参数等因素影响。
学习 JDK 25 时,应重点掌握当前轻量级锁机制,不要把 JDK 8 的偏向锁、传统
Lock Record 结构当成现代 JDK 的统一实现。
3.7 synchronized 的锁升级流程:JDK 8 与 JDK 25 要分开看
面试中常说的“无锁 → 偏向锁 → 轻量级锁 → 重量级锁”,主要是对 JDK 8
及其经典 HotSpot 锁实现的概括。它不能原样套用到 JDK 25。
JDK 8 经典实现的状态变化
对象处于无锁状态
|
| 第一个线程进入同步块,满足偏向条件
v
偏向锁 ────────────────┐
| |
| 其他线程竞争 | 原持有线程再次进入
v |
撤销偏向 / | 继续偏向原线程
进入轻量级锁 |
| |
| CAS 竞争失败、 |
| 需要膨胀 |
v |
重量级锁 <───────────────┘
理解这张图时注意:
- 偏向锁不是“先加一把真正的互斥锁”,它的目标是让锁反复由同一线程持有时,尽量减少原子操作开销。
- 发生竞争时,JVM 可能撤销偏向,并根据对象和线程状态进入轻量级锁等后续处理;撤销偏向本身不等于必然立刻膨胀为重量级锁。
- 轻量级锁通过 CAS 等快速路径处理低竞争场景;如果竞争处理需要 Monitor,便可能发生锁膨胀。
- 这是一张帮助理解的状态示意图,不代表每次加锁都严格、完整地经过每一个状态。
JDK 25 需要掌握的主流程
JDK 15 起偏向锁默认禁用并被弃用,后续版本移除了偏向锁实现。JDK 21 引入新的
Lightweight Locking,JDK 23 起默认启用。因此学习 JDK 25 时,可以重点记住:
对象处于可加锁状态
|
| 线程尝试获取 synchronized
v
轻量级锁快速路径(对象头锁状态 + 线程 Lock Stack)
|
+------ 获取成功 ------> 执行同步代码
| |
| v
| 解锁
|
| 竞争需要膨胀 / 慢路径处理
v
关联 ObjectMonitor(锁膨胀)
|
v
由 Monitor 管理 Owner、重入、竞争线程和等待线程
|
v
释放所有权;在满足条件且合适的时机,Monitor 可能被 Deflation 回收
这里有几个非常容易混淆的点:
- 轻量级锁不是“没有锁”,它仍然提供互斥,只是尽量走用户态快速路径,避免一开始就使用重量级 Monitor。
- 锁膨胀不等于所有竞争线程马上阻塞。膨胀后由 Monitor 管理竞争,线程是否自旋、排队或阻塞,取决于具体实现与运行时策略。
- 解锁不等于锁降级。线程退出同步块是释放锁;Monitor Deflation 是 JVM 在合适时机回收不再使用的 Monitor 结构,两者不是同一个动作。
- 如果 Monitor 后续被 Deflation 回收,对象可以重新处于未膨胀状态;这不代表每次释放锁都会沿着“重量级 → 轻量级 → 无锁”逐级回退。
- synchronized 是可重入的。同一线程再次进入自己持有的同一把锁,不会把它当作另一个线程的竞争;重入状态由相应锁实现维护。
面试时如何回答“锁升级过程”?
建议先确认版本,再回答:
如果说的是 JDK 8 经典实现,通常会概括为无锁、偏向锁、轻量级锁、重量级锁。偏向锁适合单线程反复进入,出现竞争时可能撤销偏向并进入轻量级锁处理;竞争进一步需要 Monitor 时发生膨胀。这个过程不是每次都必经的固定流水线。
如果是 JDK 25,就不要再讲偏向锁作为当前默认流程。现代 HotSpot 使用新的轻量级锁机制,先尝试轻量级快速路径;需要更复杂的竞争管理时再膨胀为 ObjectMonitor。释放锁和 Monitor Deflation 也要区分,Deflation 不是每次解锁都会发生的降级。
四、wait、notify、sleep
4.1 wait() 做了什么?
wait() 是 Object 的方法。调用线程必须已经持有该对象的
Monitor,否则会抛出 IllegalMonitorStateException。
synchronized (lock) {
lock.wait();
}
调用 wait() 后:
- 当前线程释放调用对象对应的 Monitor。
- 当前线程进入该对象的 WaitSet。
- 被
notify()/notifyAll()通知、超时或中断后,线程离开等待过程。 - 线程需要重新竞争并获得该 Monitor。
- 重新获得 Monitor 后,
wait()才返回,代码继续执行。
wait() 释放的是调用对象对应的
Monitor,不是线程持有的所有锁。如果线程还持有其他对象的锁,那些锁不会因为这次
wait() 自动释放。
4.2 notify() 不会直接交出锁
synchronized (lock) {
lock.notify();
// 当前线程仍然持有 lock
}
notify() 只是通知 WaitSet 中的一个线程,使其有机会离开 WaitSet
并重新参与锁竞争。调用 notify()
的线程仍然持有锁,直到退出同步区域或以其他方式释放 Monitor。
notifyAll() 会通知所有等待线程,但这些线程仍然需要逐个竞争锁。
4.3 为什么 wait() 通常必须放在 while 中?
推荐写法:
synchronized (lock) {
while (!condition) {
lock.wait();
}
doSomething();
}
不推荐:
synchronized (lock) {
if (!condition) {
lock.wait();
}
doSomething();
}
原因:
- 可能发生虚假唤醒。
- 被通知的线程重新获得锁时,条件可能已经被其他线程改变。
notifyAll()
可能唤醒多个等待线程,但条件通常只允许其中部分线程继续执行。
因此,线程每次从 wait() 返回后,都应该重新检查等待条件。
4.4 sleep() 与 wait() 的区别
| 对比 | Thread.sleep() |
Object.wait() |
|---|---|---|
| 所属类 | Thread | Object |
| 是否释放已持有的 synchronized 锁 | 不释放 | 释放调用对象对应的 Monitor |
| 是否要求持有对象 Monitor | 不要求 | 要求 |
| 典型唤醒方式 | 时间到、被中断 | notify/notifyAll、超时、被中断 |
| 线程状态 | sleep 有超时,通常为 TIMED_WAITING | 无超时通常 WAITING,有超时通常 TIMED_WAITING |
示例:
synchronized (lock) {
Thread.sleep(1000);
// 睡眠期间仍持有 lock
}
synchronized (lock) {
lock.wait();
// wait 期间释放 lock
// 重新获得 lock 后才继续
}
五、volatile
5.1 volatile 解决什么问题?
volatile 主要保证:
- 可见性:一个线程对 volatile
变量的写入,对其他线程后续读取该变量可见。 - 有序性:通过 volatile 读写语义及相应内存屏障,限制相关重排序。
示例:
public class Worker {
private volatile boolean running = true;
public void stop() {
running = false;
}
public void run() {
while (running) {
// 执行任务
}
}
}
如果 running
不具备合适的可见性保障,工作线程可能持续观察到旧值。声明为 volatile
后,停止线程写入的新值能够被工作线程后续读取观察到。
5.2 volatile 不保证复合操作的原子性
典型错误:
private volatile int count = 0;
public void increment() {
count++;
}
count++ 不是单一步骤,而是:
读取 count
↓
计算 count + 1
↓
写回 count
多个线程可能同时读取到相同旧值,最后相互覆盖。因此 volatile 不能保证
count++ 的线程安全。
如果需要原子递增,可以使用:
private final AtomicInteger count = new AtomicInteger();
public void increment() {
count.incrementAndGet();
}
或者使用 synchronized 保护复合操作。
5.3 volatile 的 happens-before 规则
一个 volatile 变量的写操作,happens-before 后续对同一个变量的读操作。
// 线程 T1
data = 100;
ready = true; // ready 是 volatile
// 线程 T2
if (ready) {
System.out.println(data);
}
当 T2 读到 ready == true 时,T1 在 volatile 写之前对 data 的写入,对
T2 可见。
这里要理解:volatile
不只是”强制从主内存读取”这么简单,更准确地说,它具有 Java
内存模型规定的可见性与有序性语义。
5.4 内存屏障怎么理解?
内存屏障(Memory Barrier /
Fence)是约束内存操作重排序、建立可见性语义的底层机制。
学习阶段先记住:
- volatile 写:具有 release 语义,不能让之前的普通写被重排到它之后。
- volatile 读:具有 acquire 语义,不能让之后的普通读被重排到它之前。
- JVM 会结合目标 CPU
架构生成合适的指令或屏障,不同平台的具体指令可能不同。
不要死记某一种 CPU 指令,面试重点是说明 volatile 在 JMM 中提供的语义。
5.5 volatile 的底层实现:从 JMM 到 JVM,再到 CPU
理解 volatile,建议分成三个层次:JMM 规定语义,JVM 将语义落实为编译器约束和内存屏障,CPU 通过自身内存模型及必要指令保证执行效果。
第一层:JMM 定义 volatile 语义
Java 内存模型并不是要求程序员真的去某个叫“主内存”的物理位置读取数据。它定义的是多线程之间允许观察到什么结果:
- 对 volatile 变量的写具有 release(释放)语义:写之前的普通读写不能被重排到这次 volatile 写之后。
- 对 volatile 变量的读具有 acquire(获取)语义:读之后的普通读写不能被重排到这次 volatile 读之前。
- 对同一个 volatile 变量,前面的 volatile 写 synchronizes-with 后续观察到该写的 volatile 读;结合程序顺序规则,建立 happens-before 关系。
示例:
// 线程 T1
int data = 42;
ready = true; // ready 是 volatile
// 线程 T2
if (ready) { // 读到 T1 写入的 true
System.out.println(data); // 能看到 data = 42
}
关键不是“ready 把 data 刷进某个固定的主内存地址”,而是 volatile 写与读建立了跨线程的顺序和可见性关系,使 data = 42 对读到 ready == true 的线程可见。
第二层:JVM 编译器屏障与内存屏障
JVM 在解释执行、即时编译等不同执行路径中,都必须遵守 JMM 规定。对经过 JIT 编译的代码,可以把相关约束概念化为:
普通写 data = 42
|
v
Release 约束 / 屏障
|
v
volatile 写 ready = true
volatile 读 ready
|
v
Acquire 约束 / 屏障
|
v
普通读 data
更准确地说,HotSpot 会在编译器中维护内存依赖与屏障节点,并在目标平台代码生成阶段映射为所需的指令或屏障。不同 JDK 版本、编译器路径和 CPU 架构的具体实现可能不同,不能把某一段汇编当成所有机器上的固定模板。
第三层:CPU 如何落实这些约束?
不同 CPU 的硬件内存模型不同,因此生成的指令也可能不同。
| 平台 | 大致特点 | volatile 实现时的关注点 |
|---|---|---|
| x86 / x86-64 | TSO 内存模型相对较强,许多 Load/Store 顺序由硬件天然保证 | 普通 volatile load/store 常可使用普通加载/存储指令;对硬件无法天然保证的顺序(尤其 StoreLoad)仍需适当屏障或带锁指令等机制 |
| ARM / AArch64 | 内存模型相对较弱,普通内存访问允许更多重排序 | 通常需要使用 acquire/release 形式的访问指令或 DMB 等屏障,具体取决于访问类型和 JVM 代码生成策略 |
所以,不能简单说“volatile 一定对应一条 lock 指令”,也不能说“volatile 每次读写都执行 mfence”。例如在 x86 上,普通 volatile 读写常常不需要每次都用完整的 mfence;JVM 会利用 x86-TSO 已经提供的顺序保证,只补足必要约束。ARM 上则可能需要更明确的 acquire/release 指令或屏障。
volatile 写和读分别要保证什么?
- volatile 写:保证它之前的普通写不能跑到 volatile 写之后;同时让其他线程后续读取该 volatile 变量时能够建立规定的可见性关系。
- volatile 读:保证它之后的普通读写不能跑到 volatile 读之前;当读到某次 volatile 写的值时,能够观察到该写之前的相关操作。
- StoreLoad 特别值得注意:volatile 写之后再进行 volatile 读的顺序,在某些硬件模型上不是天然保证的,JVM 需要确保 JMM 要求的顺序得到满足。
volatile 与 synchronized 的底层保证有什么不同?
| 对比 | volatile |
synchronized |
|---|---|---|
| 核心能力 | 可见性、有序性 | 互斥,以及锁释放/获取带来的可见性、有序性 |
| 是否互斥 | 否 | 是,同一把锁同一时刻只能由一个线程持有 |
是否保证 i++ 原子性 |
否 | 在所有相关访问都受同一把锁保护时可以 |
| 底层关注点 | volatile 访问语义、编译器/CPU 屏障 | Monitor 或轻量级锁快速路径、竞争与膨胀处理 |
| 典型用途 | 状态标记、配置发布、停止标志 | 临界区、多个变量/多个步骤的一致性 |
补充:volatile 也可以用于安全发布不可变对象或通过 volatile 引用发布已构造完成的对象,但对象内部后续发生的多个可变字段更新,不会因为引用是 volatile 就自动变成原子事务。
六、CAS 与原子类
6.1 CAS 是什么?
CAS 全称 Compare-And-Set(也常称 Compare-And-Swap)。
它的核心逻辑:
CAS(内存位置, 期望值, 新值)
如果当前值 == 期望值:
原子地更新为新值
返回成功
否则:
不更新
返回失败
CAS 是一种硬件支持的原子条件更新机制。Java 中的原子类会基于 CAS
等机制实现线程安全更新。
6.2 AtomicInteger 的基本原理
AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet();
可以把它理解为 CAS 重试循环:
int oldValue;
int newValue;
do {
oldValue = count.get();
newValue = oldValue + 1;
} while (!count.compareAndSet(oldValue, newValue));
如果其他线程先修改了值,当前线程的 CAS 就会失败,然后重新读取并尝试。
真实 JDK 实现还涉及 volatile 语义、VarHandle
或底层原子操作等细节;上面的代码是帮助理解的伪实现。
6.3 CAS 的优点与问题
优点:
- 不需要像传统互斥锁那样因每次更新都进入阻塞等待。
- 在竞争不高时,更新路径通常较短。
- 适合对单个变量做简单原子更新。
问题:
- 高竞争下 CAS 可能反复失败和重试,浪费 CPU。
- 只能直接保证对应原子变量的更新,复杂多变量操作需要额外设计。
- 可能出现 ABA 问题。
6.4 ABA 问题
假设线程 T1 读取到变量值 A,准备 CAS 更新;期间 T2 把值从 A 改为
B,又改回 A。
此时 T1 执行 CAS,发现当前值仍然是 A,于是认为没有变化并更新成功。
初始:A
|
T1 读取 A
|
T2 修改 A → B
|
T2 修改 B → A
|
T1 CAS:期望 A,当前也是 A
|
CAS 成功
问题在于:值虽然回到了 A,但中间发生过变化。
如何解决 ABA?
使用带版本号或时间戳的原子引用,例如 AtomicStampedReference:
AtomicStampedReference<String> ref =
new AtomicStampedReference<>("A", 1);
比较时除了比较引用,还比较 stamp(版本戳)。即使值从 A 变成 B 再变回
A,版本戳也已经改变。
6.5 AtomicInteger 与 LongAdder
AtomicInteger
核心是对一个变量进行原子更新,通常通过 CAS 实现。
适合:
- 普通并发计数。
- 状态标记。
- 对单个整数进行原子递增、递减或比较更新。
LongAdder
高并发计数时,多个线程反复竞争同一个 CAS 变量,可能导致大量重试。
LongAdder 采用分散竞争的思路:在竞争较高时,将更新分散到多个
Cell,再在读取时汇总。
LongAdder counter = new LongAdder();
counter.increment();
long total = counter.sum();
对比:
| 对比 | AtomicLong | LongAdder |
|---|---|---|
| 更新方式 | 主要竞争一个原子值 | 分散到多个计数单元 |
| 高竞争计数吞吐 | 竞争可能较明显 | 通常更适合高竞争计数 |
| 读取 | 获取单个原子值 | 汇总多个计数单元 |
| 读取语义 | 单个原子变量读取 | 并发更新期间的 sum 不是一个全局原子快照 |
| 典型用途 | 序号、状态值、需要原子读改写的值 | 高并发统计计数 |
重要提醒:
LongAdder适合统计计数,不适合用来生成严格唯一、连续的业务序号。sum()在并发更新期间不保证得到某一瞬间的原子快照。- 如果业务要求每次更新都能基于同一个精确值做原子决策,应谨慎选择
LongAdder。
七、三种常用并发控制方式怎么选?
| 方案 | 适用场景 | 注意点 |
|---|---|---|
synchronized |
多步骤临界区、多个变量需要一起保持一致 | 需要正确选择锁对象和锁粒度 |
volatile |
一个线程写、其他线程读的状态标记等 | 不保证 i++ 这样的复合操作原子性 |
| CAS / Atomic 类 | 单个变量的原子更新 | 关注 ABA、高竞争重试与业务原子边界 |
LongAdder |
高并发统计计数 | 不适合严格序号或依赖原子快照的场景 |
一个实用的判断顺序:
- 如果要保护多个操作或多个共享变量之间的一致性,优先考虑
synchronized等互斥方案。 - 如果只需要一个状态变量的可见性,且不涉及复合更新,可以考虑
volatile。 - 如果需要单个变量的原子更新,可以考虑原子类。
- 如果是高并发统计计数,可以评估
LongAdder。
八、Day 2 实践练习
练习 1:synchronized 计数器
分别实现:
- 不加锁的计数器。
- 使用
synchronized的计数器。 - 使用
AtomicInteger的计数器。
使用多个线程并发递增,比较最终结果。
练习 2:volatile 可见性
实现一个工作线程循环读取 volatile boolean running,主线程修改为
false,观察工作线程退出。
再将 volatile
去掉,理解可见性保障的意义。不要把”某次测试恰好能退出”当成没有问题的证明。
练习 3:CAS 计数器
使用 AtomicInteger 完成并发递增,观察最终结果,并理解 CAS 失败重试。
练习 4:对比 AtomicLong 与 LongAdder
使用不同线程数量执行大量计数更新,比较吞吐表现。测试时保证工作量、运行环境和预热方式一致;不要只根据一次运行结果下结论。
九、Day 2 高频面试题
以下题目按照”基础概念 → 底层原理 →
场景分析”组织。面试时建议先给出结论,再解释原理,最后补充生产实践。
A. synchronized 与 Monitor
1. synchronized 有什么作用?
答题要点:
- 提供互斥性。
- 通过 Monitor 的释放与后续获取建立 happens-before,保证可见性。
- 同步语义约束相关重排序,提供有序性保障。
- 需要说明锁对象是谁。
2. synchronized 的底层实现是什么?
答题要点:
- 同步代码块通常对应
monitorenter/monitorexit。 - 同步方法通过
ACC_SYNCHRONIZED标志表达同步语义。 - JVM 通过对象 Monitor 管理锁的所有权和竞争。
- HotSpot 中重量级监视器涉及
ObjectMonitor等运行时结构。
3. synchronized 的实例方法、静态方法和代码块分别锁什么?
答题要点:
- 实例同步方法:
this。 - 静态同步方法:当前类的
Class对象。 - 同步代码块:括号中指定的对象。
- 不同锁对象之间互不互斥。
4. synchronized 是可重入锁吗?为什么?
答题要点:
- 是。
- 同一线程已经持有某个 Monitor 时,可以再次进入由同一个 Monitor
保护的同步区域。 - Monitor 通过重入相关状态记录重入情况。
- 退出时需要匹配释放,不能因为重复进入就提前释放全部锁定。
B. Mark Word 与锁优化
5. 什么是 Mark Word?里面存储什么?
答题要点:
- Mark Word 是对象头的一部分。
- 可能记录对象身份哈希码、GC 年龄、锁状态等。
- 不同状态下空间复用,信息并非始终同时存在。
- 具体布局与 JVM 实现、JDK 版本及配置有关。
6. JDK 8 经典轻量级锁是如何实现的?
答题要点:
- 在线程栈帧中准备 Lock Record。
- 将原始 Mark Word 保存到
_displaced_header。 - CAS 将对象 Mark Word 替换为 Lock Record 地址。
- 解锁时 CAS 尝试恢复原始 Mark Word。
- 失败时进入慢路径处理。
7. 为什么 JDK 8 轻量级锁需要保存 Displaced Mark Word?
答题要点:
- 旧实现会用 Lock Record 地址替换对象原始 Mark Word。
- 原始信息被覆盖,所以需要在线程栈的 Lock Record 中保存副本。
- 解锁时用于恢复对象原始 Mark Word。
8. 新版轻量级锁与 JDK 8 经典实现有什么区别?
答题要点:
- 新机制采用 Lightweight Locking / Lock Stack 思路。
- 不再采用传统的”对象头指向线程栈 Lock Record”的模式。
- 通过对象头锁状态与线程本地 Lock Stack 协同记录和释放锁。
- 不需要传统 Displaced Mark Word 保存/恢复模式,因为不再整体覆盖原始
Mark Word。 - 新机制在 JDK 21 引入,JDK 23 起默认启用。
9. 什么是锁膨胀?是不是有线程竞争就一定膨胀?
答题要点:
- 锁膨胀是对象关联到重量级 Monitor,由 Monitor 管理锁竞争。
- 不是第二个线程一来就必然立即膨胀。
- 具体路径依 JVM 版本、锁状态和竞争情况而定。
- 不能把所有竞争都简单描述成线程立即阻塞。
10. 锁膨胀后能不能恢复?
答题要点:
- 解锁与 Monitor Deflation 是两个不同概念。
- 解锁是释放 Monitor 所有权。
- Deflation 是在合适条件和时机回收不再使用的 Monitor。
- 不意味着每次解锁都会立即恢复成轻量级锁。
10.1 synchronized 的锁升级流程是什么?JDK 8 和 JDK 25 有什么区别?
答题要点:
- JDK 8 经典实现常概括为无锁、偏向锁、轻量级锁、重量级锁,但不是每次必经的固定流水线。
- 偏向锁用于减少同一线程反复获取锁的开销;发生竞争时可能撤销偏向,再走轻量级锁等处理。
- 轻量级锁通过 CAS 等快速路径处理低竞争;需要 Monitor 管理竞争时发生膨胀。
- JDK 25 不应再把偏向锁作为当前默认流程;重点是新的 Lightweight Locking / Lock Stack 快速路径,以及必要时膨胀为 ObjectMonitor。
- 解锁与 Monitor Deflation 不同,不能把 Deflation 说成每次解锁都会发生的锁降级。
C. wait / notify / sleep
11. wait() 和 notify() 的作用是什么?
答题要点:
wait()要求线程持有对应对象的 Monitor。wait()释放该对象 Monitor 并进入 WaitSet。notify()通知一个等待线程,notifyAll()通知所有等待线程。- 被通知线程还要重新竞争锁,获得锁后
wait()才返回。
12. wait() 为什么必须放在 synchronized 中调用?
答题要点:
- wait/notify 操作依赖对象 Monitor。
- 调用线程必须持有该对象 Monitor。
- 否则抛出
IllegalMonitorStateException。
13. 为什么 wait() 要放在 while 中,而不是 if 中?
答题要点:
- 可能发生虚假唤醒。
- 被唤醒后条件可能已经被其他线程改变。
notifyAll()可能唤醒多个线程,但并非所有线程都满足条件。- 因此应循环检查条件。
14. sleep() 和 wait() 有什么区别?
答题要点:
sleep()是 Thread 的静态方法,不释放已持有的 synchronized 锁。wait()是 Object 的方法,释放调用对象对应的 Monitor。wait()要求当前线程持有该对象 Monitor。wait()返回前必须重新获得 Monitor。
15. notify() 之后,等待线程会立即获得锁吗?
答题要点:
- 不会。
- 通知只是让线程有机会离开 WaitSet 并重新竞争锁。
- 调用 notify 的线程仍然持有锁,直到退出同步区域等方式释放。
D. volatile
16. volatile 能保证什么?
答题要点:
- 可见性。
- 有序性。
- 对同一 volatile 变量的写与后续读建立 happens-before。
- 不保证复合操作的原子性。
17. volatile 为什么不能保证 i++ 的线程安全?
答题要点:
i++包含读取、计算、写回多个步骤。- 多线程可能同时读取相同旧值。
- volatile 不能把这些步骤组合成一个原子操作。
- 可以使用
AtomicInteger或互斥锁。
18. volatile 的底层原理是什么?
答题要点:
- JMM 定义 volatile 的可见性与有序性语义:写具有 release 语义,读具有 acquire 语义。
- HotSpot 在编译器中维护相应内存依赖/屏障约束,再结合目标 CPU 生成指令。
- x86-64 的 TSO 已天然保证部分访问顺序,通常只需补足必要屏障;ARM 等弱内存模型平台可能需要 acquire/release 指令或 DMB 屏障。
- 不要说 volatile 每次都直接读主内存,也不要说它一定对应一条 lock 指令或每次执行 mfence。
19. 什么是 happens-before?常见规则有哪些?
答题要点:
- happens-before 是 JMM 判断操作可见性与顺序约束的核心规则,不等同于现实时间上的先后,也不意味着禁止所有指令重排。
- 常见规则包括:程序顺序规则、监视器锁规则、volatile 变量规则、线程启动规则、线程终止规则、线程中断规则,以及传递性。
- 还要知道对象默认初始化先行发生于线程对该对象的其他操作。
- volatile 体现的是:对某个 volatile 变量的写,happens-before 后续对同一变量的读;结合程序顺序规则和传递性,可以把写之前的普通操作发布给读线程。
- synchronized 体现的是:对同一把锁的释放,happens-before 后续对这把锁的获取。
E. CAS 与原子类
20. 什么是 CAS?原理是什么?
答题要点:
- 比较内存位置当前值与期望值。
- 相等时原子更新为新值,不相等则失败。
- 通常由硬件原子指令支持。
- Java 原子类基于 CAS 等机制实现原子更新。
21. AtomicInteger 的 incrementAndGet() 大致如何实现?
答题要点:
- 读取当前值。
- 计算新值。
- CAS 尝试更新。
- 失败则重新读取并重试。
- 这是一个典型的 CAS 循环。
22. CAS 有什么缺点?
答题要点:
- 高竞争时可能反复失败重试,消耗 CPU。
- 可能存在 ABA 问题。
- 适合的原子边界通常是单个变量,复杂业务操作仍需额外同步设计。
23. 什么是 ABA 问题?如何解决?
答题要点:
- 值从 A 变为 B,再变回 A。
- CAS 只比较当前值时,可能误以为值从未变化。
- 可以使用
AtomicStampedReference等带版本戳的方案。
24. AtomicLong 和 LongAdder 有什么区别?
答题要点:
- AtomicLong 主要竞争同一个原子变量。
- LongAdder 在高竞争时通过多个 Cell 分散更新压力。
- LongAdder 通常更适合高并发统计计数。
- LongAdder 的 sum 在并发更新期间不是全局原子快照,不适合严格序号生成。
25. synchronized、volatile、AtomicInteger 分别适合什么场景?
答题要点:
- synchronized:保护临界区、多个操作或多个变量之间的一致性。
- volatile:状态标记等需要可见性、有序性但不需要复合原子更新的场景。
- AtomicInteger:单个整数变量的原子更新。
- 不要只凭”无锁更快”选择方案,应结合竞争程度和业务语义。
十、最后复习:Day 2 必须记住的 12 句话
synchronized提供互斥性,并通过锁释放与后续获取建立
happens-before。- 同步实例方法锁
this,静态同步方法锁Class对象。 - 同步代码块通常对应
monitorenter和monitorexit。 - Mark Word 是对象头的一部分,不同状态下会复用存储空间。
- JDK 8 经典轻量级锁使用 Lock Record 保存 Displaced Mark Word。
- JDK 8 经典实现通过 CAS 替换对象 Mark Word,并在解锁时尝试恢复。
- 新版轻量级锁使用 Lock Stack 思路,不再依赖传统 Displaced Mark Word
模式。 - 锁膨胀是关联重量级 Monitor,不代表每次竞争都立即阻塞。
wait()释放调用对象的 Monitor;notify()不会直接交出锁。sleep()不释放已经持有的 synchronized 锁。volatile保证可见性和有序性,但不保证i++的原子性。- CAS 可能遇到 ABA;高并发统计计数可以考虑 LongAdder。
Day 2 的核心不是背
API,而是能讲清楚:共享变量为什么会出问题、不同同步工具提供什么保证、JVM
如何实现锁,以及不同方案的适用边界。

浙公网安备 33010602011771号