学习目标:理解 Java 如何保证线程安全,能够解释
synchronized
的底层实现、锁状态变化、volatile的语义,以及 CAS/原子类的适用场景。本文按 Day 2 学习范围整理:synchronized → 锁优化 → volatile → CAS
与原子类。其中 JDK 8 经典锁实现与 JDK 21+
新轻量级锁实现分开说明,避免混淆不同版本。
学习具体并发工具之前,先建立一套共同的基础概念:共享变量、线程安全、JMM、原子性/可见性/有序性,以及 happens-before。后面学习 synchronized、volatile 和 CAS 时,都会反复用到这些概念。
多个线程同时访问同一份可变数据时,如果访问顺序不受正确的同步规则约束,就可能出现线程安全问题。
例如,下面的 count++ 就存在竞态风险:
private int count = 0;
public void increment() {
count++;
}
count++ 至少包含读取、计算、写回几个步骤。多个线程可能同时读到相同的旧值,导致更新丢失。后面会看到:volatile 不能让这个复合操作自动变成原子操作,而 synchronized 或 AtomicInteger 可以提供相应保护。
并发编程中经常从三个维度分析线程安全:
| 特性 | 要回答的问题 | 典型问题或例子 |
|---|---|---|
| 原子性 | 一个操作是否不可分割? | count++ 可能发生读取、计算、写回之间的交错 |
| 可见性 | 一个线程的写入,其他线程能否按规则观察到? | 线程 A 修改标志位,线程 B 仍可能读到旧值 |
| 有序性 | 编译器和 CPU 的重排序是否会破坏程序要求的顺序? | 先发布引用、后完成对象初始化可能导致不安全发布 |
这三个特性是分析问题的角度,不是三种互斥的工具。一个同步机制可能同时提供其中多种保证:
synchronized:提供互斥,并通过锁释放/获取建立可见性和有序性保证。volatile:提供可见性和有序性,但不保证 count++ 这类复合操作的原子性。Java 内存模型(Java Memory Model,JMM)是 Java 语言规范定义的一套并发访问规则。它规定了在多线程环境下,哪些写入必须对哪些读取可见,以及哪些操作之间必须保持怎样的顺序。
初学时常用“主内存”和“工作内存”来帮助理解:线程可能使用自己的工作数据副本,线程间需要通过同步机制协调共享数据。但要注意:JMM 是抽象的语义模型,不是说 JVM 中真的存在一个统一的主内存区域、每个线程也真的有一块物理工作内存。 实际实现可能涉及 CPU 缓存、寄存器、编译器优化和内存屏障等。
学习 JMM,先抓住两个问题:
而判断这些问题时,最重要的基础规则就是 happens-before。
happens-before(先行发生)是 JMM 用来描述操作之间可见性与顺序约束的规则。若操作 A happens-before 操作 B,那么 JMM 保证:A 的执行结果对 B 可见,并且 A 在语义上先行于 B。
它不等于现实时间上 A 一定比 B 早执行完,也不代表 CPU 必须把所有指令严格按源码顺序执行。只要最终结果符合 JMM 规定,编译器和 CPU 仍然可以进行合法优化。
| 规则 | 含义 | 典型例子 |
|---|---|---|
| 程序顺序规则(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 时:
data = 100 按程序顺序先于 ready = true。ready 的 volatile 写,与 T2 后续读到该写的 volatile 读建立同步关系。data。data = 100 happens-before T2 对 data 的读取,因此 T2 能看到 100。| 工具 | 主要解决的问题 | 核心机制 |
|---|---|---|
synchronized |
临界区互斥,并提供可见性、有序性保障 | Monitor / 内置锁;unlock 与后续 lock 建立 happens-before |
volatile |
可见性、有序性 | volatile 读写语义;对同一变量的写与后续读建立 happens-before |
| CAS | 对单个变量进行原子条件更新 | Compare-And-Set |
AtomicInteger 等 |
常见变量的无锁原子更新 | CAS + 相应的内存语义 |
LongAdder |
高并发计数 | 分散竞争到多个计数单元 |
要记住:这些工具不是互相替代的关系。例如 volatile 不能单独保证 i++ 的原子性;CAS 也不自动让多个变量组成的业务操作具备原子性。
synchronized 是 Java
内置的互斥同步机制。多个线程竞争同一把锁时,同一时刻最多只有一个线程能够持有该
Monitor 并执行对应的临界区。
它主要提供:
示例:
public class Counter {
private int count;
public synchronized void increment() {
count++;
}
public synchronized int get() {
return count;
}
}
这里的 synchronized 保护的是当前对象 this。如果多个线程操作的是不同
Counter 实例,它们拿到的不是同一把对象锁。
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。
每个 Java 对象都可以关联一个用于同步的 Monitor(监视器)。HotSpot
中通常由 ObjectMonitor 等运行时结构实现重量级监视器。
理解几个概念:
| 概念 | 含义 |
|---|---|
| Monitor | 监视器,管理锁的所有权、竞争和等待 |
| Owner | 当前持有 Monitor 的线程 |
EntryList / _cxq |
参与竞争 Monitor 的线程队列结构(具体组织依实现而定) |
| WaitSet | 调用该对象 wait() 后等待通知的线程集合 |
_recursions |
与 Monitor 重入相关的计数信息 |
不要把 EntryList 和 WaitSet 混为一谈:
_cxq:线程正在竞争锁。wait()notify() 让等待线程有机会重新参与锁竞争,不会直接把锁交给它。对于同步代码块,编译后的字节码通常包含:
monitorenter:进入同步区域,尝试获取对象 Monitor。monitorexit:退出同步区域,释放 Monitor。编译器还需要保证异常退出时也能释放锁,因此会生成相应的异常处理路径。
对于 synchronized
方法,通常不是在方法体中简单插入这两个指令,而是在方法访问标志中设置
ACC_SYNCHRONIZED,由 JVM 在方法调用/返回过程中处理同步语义。
以常见的 64 位 HotSpot 普通对象为例,对象头通常包含:
数组对象还包含数组长度信息。
Mark Word 的空间有限,不同锁状态下会复用其中的位,因此不能理解为
HashCode、锁指针、线程 ID 等信息永远同时存在。
Mark Word 可能涉及的信息包括:
具体位布局依赖 JVM 实现、版本和配置。不要把某张简化示意图当成所有 JDK
都通用的固定布局。
JDK 8 经典 HotSpot 实现采用传统 Stack Locking
思路。为了理解它,记住三个对象:
BasicLock)。_displaced_header。假设对象最初处于无锁状态:
synchronized。_displaced_header 中。简化示意:
加锁前:
对象 Mark Word = 原始 Mark Word
线程栈:
Lock Record(准备中)
加锁后:
对象 Mark Word = 指向 Lock Record 的指针
线程栈:
Lock Record
└── displaced_header = 原始 Mark Word
因为旧版实现会用 Lock Record 地址替换对象原来的 Mark
Word。原来的对象头信息被覆盖了,解锁时需要有地方恢复它。
关键记忆:旧版轻量级锁 = 栈上 Lock Record 保存 Displaced Mark Word +
CAS 替换/恢复对象 Mark Word。
新轻量级锁机制在 JDK 21 引入,JDK 23 起默认启用。它与 JDK 8 经典 Stack
Locking 不是同一套实现。
新版思路:
简化理解:
对象 Mark Word:
原有对象头信息 + 锁状态位
线程 Lock Stack:
记录当前线程持有的对象引用
因为新版轻量级加锁不再用 Lock Record 地址整体替换对象的 Mark Word。
旧版需要保存原始 Mark
Word,是因为原始内容被覆盖;新版保留原有对象头信息,只更新锁状态,因此不需要采用旧版那种”先保存完整原值、解锁时再恢复”的模式。
注意:
| 对比项 | 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 | 需要 | 不需要 |
锁膨胀(Lock
Inflation)指轻量级锁等快速路径无法继续满足竞争处理需求时,JVM
将对象关联到重量级 Monitor,由 Monitor 管理锁所有权和竞争线程。
简化理解:
轻量级锁快速路径
|
| 竞争/慢路径处理
v
关联 ObjectMonitor
|
v
由 Monitor 管理 Owner、竞争队列和 WaitSet
要注意:
HotSpot 有 Monitor
Deflation(监视器膨胀回收)机制,可以在合适条件和时机回收不再使用的
Monitor。
必须区分:
Deflation
不是每次解锁后立刻执行的”锁降级”,也不意味着每个对象都会马上恢复到轻量级锁状态。
JDK 8 的经典锁优化讨论中经常会提到:
但这不是每次 synchronized 都必然经历的固定流水线。偏向锁的启用还受到
JDK 版本和 JVM 参数等因素影响。
学习 JDK 25 时,应重点掌握当前轻量级锁机制,不要把 JDK 8 的偏向锁、传统
Lock Record 结构当成现代 JDK 的统一实现。
面试中常说的“无锁 → 偏向锁 → 轻量级锁 → 重量级锁”,主要是对 JDK 8
及其经典 HotSpot 锁实现的概括。它不能原样套用到 JDK 25。
对象处于无锁状态
|
| 第一个线程进入同步块,满足偏向条件
v
偏向锁 ────────────────┐
| |
| 其他线程竞争 | 原持有线程再次进入
v |
撤销偏向 / | 继续偏向原线程
进入轻量级锁 |
| |
| CAS 竞争失败、 |
| 需要膨胀 |
v |
重量级锁 <───────────────┘
理解这张图时注意:
JDK 15 起偏向锁默认禁用并被弃用,后续版本移除了偏向锁实现。JDK 21 引入新的
Lightweight Locking,JDK 23 起默认启用。因此学习 JDK 25 时,可以重点记住:
对象处于可加锁状态
|
| 线程尝试获取 synchronized
v
轻量级锁快速路径(对象头锁状态 + 线程 Lock Stack)
|
+------ 获取成功 ------> 执行同步代码
| |
| v
| 解锁
|
| 竞争需要膨胀 / 慢路径处理
v
关联 ObjectMonitor(锁膨胀)
|
v
由 Monitor 管理 Owner、重入、竞争线程和等待线程
|
v
释放所有权;在满足条件且合适的时机,Monitor 可能被 Deflation 回收
这里有几个非常容易混淆的点:
建议先确认版本,再回答:
如果说的是 JDK 8 经典实现,通常会概括为无锁、偏向锁、轻量级锁、重量级锁。偏向锁适合单线程反复进入,出现竞争时可能撤销偏向并进入轻量级锁处理;竞争进一步需要 Monitor 时发生膨胀。这个过程不是每次都必经的固定流水线。
如果是 JDK 25,就不要再讲偏向锁作为当前默认流程。现代 HotSpot 使用新的轻量级锁机制,先尝试轻量级快速路径;需要更复杂的竞争管理时再膨胀为 ObjectMonitor。释放锁和 Monitor Deflation 也要区分,Deflation 不是每次解锁都会发生的降级。
wait() 是 Object 的方法。调用线程必须已经持有该对象的
Monitor,否则会抛出 IllegalMonitorStateException。
synchronized (lock) {
lock.wait();
}
调用 wait() 后:
notify() / notifyAll() 通知、超时或中断后,线程离开等待过程。wait() 才返回,代码继续执行。wait() 释放的是调用对象对应的
Monitor,不是线程持有的所有锁。如果线程还持有其他对象的锁,那些锁不会因为这次
wait() 自动释放。
synchronized (lock) {
lock.notify();
// 当前线程仍然持有 lock
}
notify() 只是通知 WaitSet 中的一个线程,使其有机会离开 WaitSet
并重新参与锁竞争。调用 notify()
的线程仍然持有锁,直到退出同步区域或以其他方式释放 Monitor。
notifyAll() 会通知所有等待线程,但这些线程仍然需要逐个竞争锁。
推荐写法:
synchronized (lock) {
while (!condition) {
lock.wait();
}
doSomething();
}
不推荐:
synchronized (lock) {
if (!condition) {
lock.wait();
}
doSomething();
}
原因:
notifyAll()因此,线程每次从 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 主要保证:
示例:
public class Worker {
private volatile boolean running = true;
public void stop() {
running = false;
}
public void run() {
while (running) {
// 执行任务
}
}
}
如果 running
不具备合适的可见性保障,工作线程可能持续观察到旧值。声明为 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 保护复合操作。
一个 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
内存模型规定的可见性与有序性语义。
内存屏障(Memory Barrier /
Fence)是约束内存操作重排序、建立可见性语义的底层机制。
学习阶段先记住:
不要死记某一种 CPU 指令,面试重点是说明 volatile 在 JMM 中提供的语义。
理解 volatile,建议分成三个层次:JMM 规定语义,JVM 将语义落实为编译器约束和内存屏障,CPU 通过自身内存模型及必要指令保证执行效果。
Java 内存模型并不是要求程序员真的去某个叫“主内存”的物理位置读取数据。它定义的是多线程之间允许观察到什么结果:
示例:
// 线程 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 在解释执行、即时编译等不同执行路径中,都必须遵守 JMM 规定。对经过 JIT 编译的代码,可以把相关约束概念化为:
普通写 data = 42
|
v
Release 约束 / 屏障
|
v
volatile 写 ready = true
volatile 读 ready
|
v
Acquire 约束 / 屏障
|
v
普通读 data
更准确地说,HotSpot 会在编译器中维护内存依赖与屏障节点,并在目标平台代码生成阶段映射为所需的指令或屏障。不同 JDK 版本、编译器路径和 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 |
synchronized |
|---|---|---|
| 核心能力 | 可见性、有序性 | 互斥,以及锁释放/获取带来的可见性、有序性 |
| 是否互斥 | 否 | 是,同一把锁同一时刻只能由一个线程持有 |
是否保证 i++ 原子性 |
否 | 在所有相关访问都受同一把锁保护时可以 |
| 底层关注点 | volatile 访问语义、编译器/CPU 屏障 | Monitor 或轻量级锁快速路径、竞争与膨胀处理 |
| 典型用途 | 状态标记、配置发布、停止标志 | 临界区、多个变量/多个步骤的一致性 |
补充:volatile 也可以用于安全发布不可变对象或通过 volatile 引用发布已构造完成的对象,但对象内部后续发生的多个可变字段更新,不会因为引用是 volatile 就自动变成原子事务。
CAS 全称 Compare-And-Set(也常称 Compare-And-Swap)。
它的核心逻辑:
CAS(内存位置, 期望值, 新值)
如果当前值 == 期望值:
原子地更新为新值
返回成功
否则:
不更新
返回失败
CAS 是一种硬件支持的原子条件更新机制。Java 中的原子类会基于 CAS
等机制实现线程安全更新。
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
或底层原子操作等细节;上面的代码是帮助理解的伪实现。
优点:
问题:
假设线程 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,但中间发生过变化。
使用带版本号或时间戳的原子引用,例如 AtomicStampedReference:
AtomicStampedReference<String> ref =
new AtomicStampedReference<>("A", 1);
比较时除了比较引用,还比较 stamp(版本戳)。即使值从 A 变成 B 再变回
A,版本戳也已经改变。
核心是对一个变量进行原子更新,通常通过 CAS 实现。
适合:
高并发计数时,多个线程反复竞争同一个 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。分别实现:
synchronized 的计数器。AtomicInteger 的计数器。使用多个线程并发递增,比较最终结果。
实现一个工作线程循环读取 volatile boolean running,主线程修改为
false,观察工作线程退出。
再将 volatile
去掉,理解可见性保障的意义。不要把”某次测试恰好能退出”当成没有问题的证明。
使用 AtomicInteger 完成并发递增,观察最终结果,并理解 CAS 失败重试。
使用不同线程数量执行大量计数更新,比较吞吐表现。测试时保证工作量、运行环境和预热方式一致;不要只根据一次运行结果下结论。
以下题目按照”基础概念 → 底层原理 →
场景分析”组织。面试时建议先给出结论,再解释原理,最后补充生产实践。
答题要点:
答题要点:
monitorenter / monitorexit。ACC_SYNCHRONIZED 标志表达同步语义。ObjectMonitor 等运行时结构。答题要点:
this。Class 对象。答题要点:
答题要点:
答题要点:
_displaced_header。答题要点:
答题要点:
答题要点:
答题要点:
答题要点:
答题要点:
wait() 要求线程持有对应对象的 Monitor。wait() 释放该对象 Monitor 并进入 WaitSet。notify() 通知一个等待线程,notifyAll() 通知所有等待线程。wait() 才返回。答题要点:
IllegalMonitorStateException。答题要点:
notifyAll() 可能唤醒多个线程,但并非所有线程都满足条件。答题要点:
sleep() 是 Thread 的静态方法,不释放已持有的 synchronized 锁。wait() 是 Object 的方法,释放调用对象对应的 Monitor。wait() 要求当前线程持有该对象 Monitor。wait() 返回前必须重新获得 Monitor。答题要点:
答题要点:
答题要点:
i++ 包含读取、计算、写回多个步骤。AtomicInteger 或互斥锁。答题要点:
答题要点:
答题要点:
答题要点:
答题要点:
答题要点:
AtomicStampedReference 等带版本戳的方案。答题要点:
答题要点:
synchronized 提供互斥性,并通过锁释放与后续获取建立this,静态同步方法锁 Class 对象。monitorenter 和 monitorexit。wait() 释放调用对象的 Monitor;notify() 不会直接交出锁。sleep() 不释放已经持有的 synchronized 锁。volatile 保证可见性和有序性,但不保证 i++ 的原子性。Day 2 的核心不是背
API,而是能讲清楚:共享变量为什么会出问题、不同同步工具提供什么保证、JVM
如何实现锁,以及不同方案的适用边界。