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,先抓住两个问题:

  1. 可见性:线程 A 的写入,线程 B 在什么条件下必须能够观察到?
  2. 有序性:编译器或 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 时:

  1. T1 中 data = 100 按程序顺序先于 ready = true。
  2. 对 ready 的 volatile 写,与 T2 后续读到该写的 volatile 读建立同步关系。
  3. T2 中 volatile 读按程序顺序先于读取 data。
  4. 根据传递性,data = 100 happens-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 普通对象为例,对象头通常包含:

  1. Mark Word:记录对象运行时状态信息。
  2. 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。

加锁过程

假设对象最初处于无锁状态:

  1. 线程准备进入 synchronized。
  2. 在线程栈帧中准备 Lock Record。
  3. 将对象原始 Mark Word 复制到 Lock Record 的 _displaced_header 中。
  4. 通过 CAS 尝试把对象 Mark Word 替换为指向 Lock Record 的指针。
  5. CAS 成功,表示获取轻量级锁成功;失败则进入相应的慢路径处理。

简化示意:

加锁前:
对象 Mark Word = 原始 Mark Word

线程栈:
Lock Record(准备中)

加锁后:
对象 Mark Word = 指向 Lock Record 的指针

线程栈:
Lock Record
  └── displaced_header = 原始 Mark Word

为什么要保存原始 Mark Word?

因为旧版实现会用 Lock Record 地址替换对象原来的 Mark
Word。原来的对象头信息被覆盖了,解锁时需要有地方恢复它。

解锁过程

  1. 线程读取 Lock Record 中保存的原始 Mark Word。
  2. 通过 CAS 尝试把对象 Mark Word 从 Lock Record 指针恢复成原始 Mark
    Word。
  3. CAS 成功,完成快速解锁。
  4. 如果 CAS
    失败,说明对象锁状态可能已经变化,例如发生了锁膨胀,需要走慢路径。

关键记忆:旧版轻量级锁 = 栈上 Lock Record 保存 Displaced Mark Word +
CAS 替换/恢复对象 Mark Word。

3.3 新版轻量级锁:Lightweight Locking / Lock Stack

新轻量级锁机制在 JDK 21 引入,JDK 23 起默认启用。它与 JDK 8 经典 Stack
Locking 不是同一套实现。

新版思路:

  1. 对象处于可加锁状态时,线程通过 CAS 更新 Mark Word 中的锁状态。
  2. 不再采用”把对象头替换成线程栈中 Lock Record 地址”的传统方式。
  3. 当前线程通过自己的 Lock Stack 记录持有轻量级锁的对象引用。
  4. 解锁时结合对象头状态和线程的 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                    |
   重量级锁 <───────────────┘

理解这张图时注意:

  1. 偏向锁不是“先加一把真正的互斥锁”,它的目标是让锁反复由同一线程持有时,尽量减少原子操作开销。
  2. 发生竞争时,JVM 可能撤销偏向,并根据对象和线程状态进入轻量级锁等后续处理;撤销偏向本身不等于必然立刻膨胀为重量级锁。
  3. 轻量级锁通过 CAS 等快速路径处理低竞争场景;如果竞争处理需要 Monitor,便可能发生锁膨胀。
  4. 这是一张帮助理解的状态示意图,不代表每次加锁都严格、完整地经过每一个状态。

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() 后:

  1. 当前线程释放调用对象对应的 Monitor。
  2. 当前线程进入该对象的 WaitSet。
  3. 被 notify() / notifyAll() 通知、超时或中断后,线程离开等待过程。
  4. 线程需要重新竞争并获得该 Monitor。
  5. 重新获得 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();
}

原因:

  1. 可能发生虚假唤醒。
  2. 被通知的线程重新获得锁时,条件可能已经被其他线程改变。
  3. 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 主要保证:

  1. 可见性:一个线程对 volatile
    变量的写入,对其他线程后续读取该变量可见。
  2. 有序性:通过 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 高并发统计计数 不适合严格序号或依赖原子快照的场景

一个实用的判断顺序:

  1. 如果要保护多个操作或多个共享变量之间的一致性,优先考虑
    synchronized 等互斥方案。
  2. 如果只需要一个状态变量的可见性,且不涉及复合更新,可以考虑
    volatile。
  3. 如果需要单个变量的原子更新,可以考虑原子类。
  4. 如果是高并发统计计数,可以评估 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 句话

  1. synchronized 提供互斥性,并通过锁释放与后续获取建立
    happens-before。
  2. 同步实例方法锁 this,静态同步方法锁 Class 对象。
  3. 同步代码块通常对应 monitorenter 和 monitorexit。
  4. Mark Word 是对象头的一部分,不同状态下会复用存储空间。
  5. JDK 8 经典轻量级锁使用 Lock Record 保存 Displaced Mark Word。
  6. JDK 8 经典实现通过 CAS 替换对象 Mark Word,并在解锁时尝试恢复。
  7. 新版轻量级锁使用 Lock Stack 思路,不再依赖传统 Displaced Mark Word
    模式。
  8. 锁膨胀是关联重量级 Monitor,不代表每次竞争都立即阻塞。
  9. wait() 释放调用对象的 Monitor;notify() 不会直接交出锁。
  10. sleep() 不释放已经持有的 synchronized 锁。
  11. volatile 保证可见性和有序性,但不保证 i++ 的原子性。
  12. CAS 可能遇到 ABA;高并发统计计数可以考虑 LongAdder。

Day 2 的核心不是背
API,而是能讲清楚:共享变量为什么会出问题、不同同步工具提供什么保证、JVM
如何实现锁,以及不同方案的适用边界。

posted @ 2026-11-17 21:16  zhangph  阅读(6)  评论(0)    收藏  举报