Java Monitor详解:从synchronized到wait与notify

学习 Java 并发时,经常会遇到几个看似独立的问题:synchronized 到底锁住了什么?wait() 为什么要放在同步块里?notify() 已经唤醒了线程,为什么它还不能继续执行?

把这些问题串起来的,就是 Monitor(监视器,也常称为管程)。

本文先用一个“会议室”的例子建立直觉,再沿着代码、线程状态和 JVM 实现逐步展开。

阅读约定:语言语义以 Java SE 25 规范为参照;示例使用 Java 8 及以上可用的语法。涉及 HotSpot 内部字段时,固定参考 OpenJDK 25 GA 源码。实现细节不能当作所有 JVM、所有版本的共同承诺。

1. Monitor解决什么问题?

假设有一间只能容纳一个人操作设备的会议室:

  • 门口的钥匙控制谁能进去,解决互斥访问。
  • 进去后发现材料还没准备好,可以先交还钥匙,去休息区等,解决条件等待。
  • 材料准备好后,有人通知休息区的人重新尝试。

Java 用 synchronized 完成进入和退出的互斥控制,用 wait/notify/notifyAll 完成条件等待与通知。理解它们时,可以把 Monitor 看作“互斥锁 + 条件等待机制”。

注意:门锁只约束遵守规则的人。一个线程持有对象的 Monitor,并不妨碍其他线程直接调用该对象的普通方法或访问未受保护的字段。因此,共享状态的所有相关访问必须遵守同一套加锁协议。Oracle 内置锁教程

Monitor概念模型:锁竞争区、持有者与条件等待集合

图中的“锁竞争区”是便于理解的抽象,不代表 Java 规范要求存在一个固定名称、固定结构的 FIFO 队列。

2. synchronized到底锁谁?

判断两段代码是否互斥,第一步是看它们竞争的是不是同一个对象的 Monitor。

写法 对应的锁对象
synchronized (lock) { ... } 表达式 lock 求值得到的对象
实例同步方法 当前接收者 this
静态同步方法 声明该方法的类所对应的 Class 对象
1
2
3
4
5
6
7
8
9
10
11
class Counter {
private int value;

public synchronized void increment() {
value++;
}

public synchronized int get() {
return value;
}
}

同一个 Counter 实例的两个方法共用一把锁;两个不同实例各有自己的锁,可以分别执行。静态同步方法和实例同步方法通常也不共用锁。锁对象的具体规则见 Oracle 同步方法与内置锁说明。

项目里也经常用专用锁对象,让保护范围更明确:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private final Object lock = new Object();
private int count;

public void increment() {
synchronized (lock) {
count++;
}
}

public int get() {
synchronized (lock) {
return count;
}
}

这里的 final 保证锁引用不会被重新赋值。不要在每次调用时都 synchronized (new Object()):每个线程拿到不同的对象,就无法通过它们建立互斥。

同样,锁住 a 后对 b 做修改,在语法上完全合法。真正的规则是“哪些数据约定由这把锁保护”,而不是“锁对象只能保护自己的字段”。

3. 一次加锁经历了什么?

在逻辑上,可以把过程拆成四步:

  1. 线程尝试获得目标对象的 Monitor。
  2. 如果其他线程持有它,当前线程需要等待获得锁。
  3. 获得锁后执行临界区。
  4. 正常结束或因异常退出同步范围时,释放相应的锁持有层数。

**Monitor是可重入的。**同一个线程已经持有某把锁,再次进入以同一对象为锁的同步范围,不会把自己挡在门外;它必须退出所有对应的重入层次,其他线程才可能获得锁。这个保证来自 JLS §17.1。

1
2
3
4
5
6
7
8
9
class ReentrantDemo {
public synchronized void outer() {
inner(); // 同一个线程再次获取 this 的 Monitor
}

public synchronized void inner() {
System.out.println("进入 inner");
}
}

还有一点容易误会:锁的身份按对象确定,和 equals() 的返回值无关。两个内容相等但身份不同的对象,仍然是两把锁。

4. 从字节码看Monitor

保存下面的代码为 MonitorBytecode.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MonitorBytecode {
private final Object lock = new Object();

public void block() {
synchronized (lock) {
System.out.println("block");
}
}

public synchronized void method() {
System.out.println("method");
}
}

执行:

1
2
javac MonitorBytecode.java
javap -c -v MonitorBytecode

观察两处差别:

  • 同步代码块通常编译出 monitorenter 和 monitorexit。反编译结果中还会看到异常处理路径上的 monitorexit,用于保证异常退出时也释放锁。
  • 同步方法带有 ACC_SYNCHRONIZED 标志。JVM 在方法调用和退出时处理同步,不要求方法体内显式出现这两条指令。

因此,“所有 synchronized 都是在方法体里插入一对 Monitor 指令”并不准确。字节码表达同步语义,执行时 JVM 还可以在不改变可观察行为的前提下进行优化。JVMS §2.11.10

5. wait与notify:等条件,不只是等锁

现在看一个消费者:它已经获得锁,却发现容器里没有数据。如果一直持锁等着,生产者就无法获得同一把锁放入数据。

wait() 解决的正是这个问题:暂时放弃当前对象的 Monitor,让其他线程有机会改变条件。

5.1 一条完整的等待路径

设消费者 C 和生产者 P 共用 lock:

  1. C 获得 lock,检查“是否有数据”。
  2. 没有数据,C 调用 lock.wait(),进入该对象的等待集合,并释放该对象的锁。
  3. P 获得 lock,放入数据,调用 lock.notifyAll()。
  4. P 继续执行同步块,直到退出才释放锁。
  5. C 重新获得 lock,从 wait() 后继续,重新检查条件。

wait与notifyAll时序:通知后需要重新获得锁

这里有两个关键边界:wait() 只释放调用对象对应的 Monitor;如果当前线程还持有其他对象的锁,那些锁不会一并释放。重入情况下,等待会释放该对象的全部持有层数,并在恢复时恢复原来的持有状态。Object.wait API

5.2 notify不会交出锁

可以把通知理解为:“情况可能变了,你可以重新来检查。”它不是“现在轮到你执行”。

通知方仍可继续执行同步代码。被通知的线程也没有优先获得锁的保证,新的竞争者可能先拿到锁。因此,不要把 notify() 当成锁所有权的直接移交。Object.notify API

5.3 为什么必须持有同一个对象的锁?

下面的代码会抛出 IllegalMonitorStateException:

1
2
Object lock = new Object();
lock.wait(); // 当前线程没有持有 lock 的 Monitor

锁错对象也不行:

1
2
3
synchronized (lockA) {
lockB.notifyAll(); // 仅持有 lockA,不能据此通知 lockB
}

wait/notify/notifyAll 都要求调用线程持有目标对象的 Monitor。把“检查条件”和“进入等待”放进同一个同步协议,也避免了通知恰好夹在两者之间而被错过的问题。Object API

6. 为什么wait外面必须写while?

错误写法:

1
2
3
4
if (!ready) {
lock.wait();
}
consume();

它隐含了一个错误假设:wait() 正常返回,就代表 ready 一定为真。

考虑这个调度过程:生产者放入一个元素,通知两个消费者;消费者 A 先获得锁,取走了唯一的元素;消费者 B 随后获得锁。如果 B 不再检查条件,就可能从空容器里取数据。

此外,等待还可能发生虚假唤醒,共享等待集合中的通知也可能对应另一种业务条件。正确模板是:

1
2
3
4
5
6
synchronized (lock) {
while (!ready) {
lock.wait();
}
consume();
}

while 表达的是:**拿到锁之后,只有业务条件成立才允许继续。**这也是 Oracle Guarded Blocks 教程推荐的模式。

通知本身不会保存为一张以后可以消费的“通行证”。如果先通知、后等待,后来的 wait() 不会自动获得此前的通知。所以程序应保存 ready、队列内容等真实状态,而不是依赖通知次数。

7. 可运行示例:单槽生产者消费者

下面用一个容量为 1 的容器,把互斥、条件判断和通知连起来。保存为 MonitorDemo.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public class MonitorDemo {
static final class OneSlot {
private final Object lock = new Object();
private Integer item; // null 表示空;状态只在 lock 保护下读写

public void put(int value) throws InterruptedException {
synchronized (lock) {
while (item != null) {
lock.wait();
}
item = value;
lock.notifyAll();
}
}

public int take() throws InterruptedException {
synchronized (lock) {
while (item == null) {
lock.wait();
}
int value = item;
item = null;
lock.notifyAll();
return value;
}
}
}

public static void main(String[] args) throws InterruptedException {
OneSlot slot = new OneSlot();

Thread producer = new Thread(() -> {
try {
for (int i = 1; i <= 5; i++) {
slot.put(i);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}, "producer");

Thread consumer = new Thread(() -> {
try {
for (int i = 1; i <= 5; i++) {
System.out.println("take: " + slot.take());
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}, "consumer");

consumer.start();
producer.start();
producer.join();
consumer.join();
}
}

运行命令:

1
2
javac MonitorDemo.java
java MonitorDemo

正常运行会依次输出 take: 1 到 take: 5。无论哪个线程先启动,容器状态都会决定是否等待,不需要依赖 sleep() 来“保证执行顺序”。

这段实现的关键在于:检查条件、修改状态、进入等待都围绕同一个 lock;生产者等待“槽位为空”,消费者等待“槽位非空”。两种条件共用一个等待集合,使用 notifyAll() 让候选线程分别检查自己的条件,更容易保证多生产者、多消费者扩展时的正确性。

notify() 只挑选一个等待者,未必选中能推进业务的那类线程;它适用于能证明唤醒任意一个候选者都足够的场景。notifyAll() 也有竞争和调度成本,不能简单认为调用越多越好。Guarded Blocks

示例通过声明 throws InterruptedException 把取消信号交给上层,线程入口恢复中断标记并结束工作。这不是完整的容器关闭协议:如果任一工作线程独立取消,另一端仍可能等待。生产代码应设计结束标记、超时或统一取消机制;常规生产者消费者需求可以直接使用 BlockingQueue。

8. BLOCKED和WAITING有什么区别?

场景 Java线程状态 是否持有目标Monitor
等待进入其他线程持有的同步范围 BLOCKED 否
调用无超时的 wait(),正在等待 WAITING 否
调用带正数超时的 wait(...),正在等待 TIMED_WAITING 否
等待结束后,仍需获得被其他线程持有的Monitor BLOCKED 否
在同步块里调用 Thread.sleep(...) TIMED_WAITING 是,sleep不会释放锁

状态是某一时刻的快照。如果通知发生时锁已经可用,可能很快重新进入执行,未必能观察到中间的 BLOCKED。另外,WAITING 还可能由 join()、park() 等操作引起,不能仅凭这个状态判断线程一定在 Object.wait()。Thread.State API

sleep() 与 wait() 的核心区别也在这里:前者暂停当前线程且保留已有锁,后者参与某个对象的条件等待并释放该对象的锁。sleep() 本身没有同步语义,不能用它替代共享变量的可见性保障。JLS §17.3

9. Monitor如何保证可见性?

只说“同一时刻只有一个线程进入”还不完整:线程之间还需要正确观察共享状态。

Java 内存模型规定:**对某个 Monitor 的解锁,happens-before 后续对同一个 Monitor 的加锁。**结合线程内部的程序顺序和传递性,前一个线程释放锁之前的写入,对随后获得同一把锁的线程可见。JLS §17.4.5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 初始:int data = 0; boolean ready = false;
// 两个线程共享同一个 lock

// 线程 A
synchronized (lock) {
data = 42;
ready = true;
}

// 线程 B
synchronized (lock) {
if (ready) {
System.out.println(data); // 观察到 ready 为 true 时,data 为 42
}
}

这里并不保证 A 一定先执行。如果 B 先获得锁,它可以看到 ready == false。同步保证的是满足顺序条件后的内存可见性,不负责替程序安排业务执行顺序。

也不要简单描述为“加锁后所有 CPU 缓存都会刷新”。happens-before 是程序可依赖的语义,JVM 和硬件如何实现这个语义是另一层问题。若 B 完全不加锁地读这些普通字段,就不能借用上面的同锁保证。

10. HotSpot中的ObjectMonitor是什么?

到这里讨论的是程序行为。进入 HotSpot 源码层面,才会看到具体的 ObjectMonitor 结构。

在 OpenJDK 25 GA 的 objectMonitor.hpp 中,可以关注下面这些字段:

字段 阅读源码时的关注点
_owner Monitor的所有权信息,具体编码依赖实现
_recursions 重入相关计数;不要直接假定它等于源码层的进入次数
_entry_list / _entry_list_tail 等待进入或重新进入Monitor的链表及尾指针
_wait_set 调用 Object.wait() 的等待者集合

这些字段能帮助解释“锁竞争”和“条件等待”为什么是两回事;但不能据此推导出锁一定公平,或通知后一定按固定 FIFO 顺序运行。具体的迁移和竞争策略需要继续阅读同版本的 objectMonitor.cpp。旧版资料常见的 _EntryList、_cxq、_WaitSet 组合,与这里引用的版本并不一致,不能混用字段名和结构图。

尤其要分清三层概念:

  1. 语言层的Monitor语义:互斥、重入、等待通知与内存可见性。
  2. class文件的表达:Monitor指令或同步方法标志。
  3. HotSpot运行时的实现:快速加锁路径、膨胀后的 ObjectMonitor 等机制。

从规范上说,每个对象都关联一个 Monitor,不等于每创建一个对象就立即分配一个独立的重量级 ObjectMonitor。是否需要物化相应结构、如何快速获得锁,是 JVM 的实现选择。JLS §17.1、JVMS §2.11.10

阅读旧资料时,还要留意版本:

  • 偏向锁:JDK 15 已默认禁用并弃用相关选项,因此“无锁→偏向锁→轻量级锁→重量级锁”不能当成现代 HotSpot 的通用执行路线。Oracle Java 15 发布说明
  • 虚拟线程:JDK 24 的 JEP 491 改进了同步构造中的阻塞,使相关虚拟线程能够释放底层平台线程。不要把早期版本中 synchronized 相关的 pinning 问题直接套用到所有新版本。Oracle JDK 24 迁移指南

无论实现怎样优化,代码仍然必须遵守同一把锁、循环检查条件等同步规则。

11. Monitor与ReentrantLock、Condition怎么对应?

内置Monitor机制 显式锁与条件机制
synchronized 进入与退出 lock() / unlock()
Object.wait() Condition.await()
Object.notify() Condition.signal()
Object.notifyAll() Condition.signalAll()
一个对象的一套等待集合 一把Lock可以创建多个Condition

这是一张功能对应表,不表示两者实现相同。Condition 把等待条件拆出来,例如用 notEmpty 和 notFull 分别管理消费方和生产方。常见的 ReentrantLock 还提供可中断获取锁、定时尝试获取锁等能力。Condition API

如果只是保护一小段共享状态,synchronized 通常足够直接;如果需要多个条件队列或更灵活的获取锁策略,再考虑显式锁。不能仅凭“底层机制更多”就判断哪一种一定更快。

12. 用几个问题检查是否理解

为什么wait/notify定义在Object上?

因为它们围绕目标对象的 Monitor 和等待集合工作。调用 lock.wait() 的含义,是“当前线程在 lock 对应的条件等待机制中等待”,并非“让 lock 这个对象休眠”。

notifyAll之后,等待者能同时执行同步块吗?

不能。通知改变等待资格,互斥规则仍然有效;它们必须逐个获得同一把锁,重新检查各自的条件。

wait释放锁之后,会从同步块开头重新执行吗?

不会。正常返回时从 wait() 后继续;代码之所以重新检查条件,是因为外层显式写了 while。

synchronized能防止死锁吗?

不能。它解决的是某个 Monitor 的互斥与可见性。两个线程以相反顺序持有并申请两把锁,仍可能死锁。尤其要注意:在持有 A 锁时执行 B.wait(),即使已经合法持有 B,等待也只释放 B,A 仍被占有。

排查时先看什么?

先找共享状态由哪把锁保护,再看条件检查是否处于锁内、等待是否放在循环里、改变条件后是否有正确通知。最后再根据实际 JDK 版本分析线程状态和 JVM 实现,通常比直接从对象头位图入手更容易定位问题。