Appearance
2.4-9 线程协作:wait/notify、Condition、park/unpark、同步器
所属:02 Java 运行时 / 2.4 并发 分级:B(按 A 类模板展开) 状态:◐ 初稿 关联:2.4-1、2.4-3、2.4-6、2.4-10、2.4-11
题型:原理 / 对比 / 场景
一句话结论:线程协作分三层:Object monitor 的
wait/notify、Lock/AQS 的Condition、最底层的LockSupport.park/unpark;CountDownLatch/Semaphore基于 AQS 共享模式,CyclicBarrier基于ReentrantLock + Condition,Phaser自管理 phase/parties。所有等待都必须放在while谓词循环里,处理虚假唤醒、丢失唤醒和中断。分层要点:
- wait/notify 与 monitor:
wait/notify/notifyAll是Object上的方法,必须在synchronized内调用,否则IllegalMonitorStateException。wait原子地释放 monitor 并把线程放入 WaitSet;notify/notifyAll把等待者从 WaitSet 移到 EntryList,通知线程退出同步块后,等待者重新竞争 monitor。wait可能虚假唤醒,必须用while (!condition);notify先于wait会丢失唤醒;notify只唤醒一个且不保证公平,多个等待条件时容易唤醒错对象。 - Condition 与 AQS:
Condition是Lock上的“多等待集”,由lock.newCondition()创建。await释放锁(ReentrantLock会释放全部重入计数)并把节点挂到 condition queue,signal把节点转到 AQS 的 sync queue,等待者重新竞争锁;signal本身不释放锁。必须持锁调用await/signal,否则IllegalMonitorStateException。一个锁可以建多个 Condition,ArrayBlockingQueue的notEmpty/notFull就是典型。 - park/unpark:
LockSupport.park/unpark是最底层阻塞原语,基于每个线程的 permit,permit 是二值的、不累计:多次unpark只相当于一次许可,unpark可以先于park调用,许可会保留到下一次park。park可能虚假唤醒;被中断时直接返回并保留中断位,不抛InterruptedException。AQS、Condition、ForkJoinPool 都建立在它上面。 - CountDownLatch 与 Semaphore:两者都基于 AQS 共享模式。
CountDownLatch的state是剩余计数,await在state != 0时排队,countDown递减到 0 时唤醒所有等待者;一次性,不能 reset、不能增加计数。Semaphore的state是许可数,acquire减、release加,支持公平/非公平;release不校验 owner,可能超过初始许可;Semaphore(1)是互斥量但不是可重入锁。 - CyclicBarrier:固定 parties 的可复用屏障,内部是
ReentrantLock + Condition + Generation。每个线程await递减 count,最后一个到达的线程执行barrierCommand,然后nextGeneration重置 count 并signalAll;超时、中断或屏障动作异常会breakBarrier,其他线程收到BrokenBarrierException,需要reset()或重建。await返回到达序号,最后一个到达者返回 0。 - Phaser:多阶段、可动态注册/注销的屏障。
state高位是 phase,中间是 parties,低位是 unarrived;最后到达者推进 phase,调用onAdvance(phase, parties),返回 true 则终止。支持arrive、arriveAndAwaitAdvance、arriveAndDeregister、awaitAdvance,支持分层 Phaser;parties 上限 65535。它比 CyclicBarrier 灵活,但状态机和排查更复杂。 - 选型与排查:简单 monitor 协作用
wait/notify;需要多个独立等待条件用Condition;自己写同步器用park/unpark;等 N 个事件用CountDownLatch;N 个线程对齐用CyclicBarrier;限并发/资源池用Semaphore;多阶段、动态 parties 用Phaser。排查看 jstack 的BLOCKED(等 monitor)、WAITING(wait/join/park)、TIMED_WAITING(sleep/wait(timeout)/parkNanos),再结合栈里的Object.wait、Condition.await、LockSupport.park判断。
- wait/notify 与 monitor:
图/流程:
text
线程协作的三层
┌──────────────────────────────────────────────┐
│ 同步器:CountDownLatch / CyclicBarrier / │
│ Semaphore / Phaser │
├──────────────────────────────────────────────┤
│ AQS 共享模式:Latch / Semaphore │
│ ReentrantLock + Condition:CyclicBarrier │
│ 自研 state + QNode:Phaser │
├──────────────────────────────────────────────┤
│ LockSupport.park / unpark(per-thread permit)│
├──────────────────────────────────────────────┤
│ Object.wait / notify(monitor WaitSet) │
└──────────────────────────────────────────────┘java
// wait/notify:谓词 + while,通知和等待用同一把锁
synchronized (lock) {
while (!ready) {
lock.wait();
}
// 条件满足后继续
}
// Condition:每个条件一个等待队列
lock.lock();
try {
while (queue.isEmpty()) {
notEmpty.await();
}
// ...
} finally {
lock.unlock();
}text
Condition.await()
├─ 保存重入计数
├─ 释放锁
├─ 节点入 condition queue
└─ LockSupport.park
Condition.signal()
├─ 要求持有锁
├─ condition queue 头节点 → AQS sync queue
└─ unpark;signal 不释放锁版本/源码锚点:
- JDK 5:
java.util.concurrent、AQS、LockSupport、Condition、CountDownLatch、CyclicBarrier、Semaphore。 - JDK 7:
Phaser引入。 - JDK 8:
Condition/AQS 的LockSupport.park实现成熟;StampedLock等新同步器(另见 2.4-4)。 - JDK 21:虚拟线程正式;
LockSupport.park/Condition.await是虚拟线程感知的挂起点;Object.wait仍依赖 monitor,synchronized在 JDK 24 前可能 pin(详见 2.4-11)。 - JDK 24:JEP 491 让
synchronized不再固定载体线程。 - 源码:
Object.wait/notify、ObjectMonitor的 WaitSet;AQS.ConditionObject.await/signal/transferForSignal;LockSupport.park/unpark;CountDownLatch.Sync;CyclicBarrier.dowait/nextGeneration/breakBarrier;Semaphore.Sync;Phaser.doArrive/onAdvance。
- JDK 5:
wait/notify vs Condition vs park/unpark:
| 维度 | wait/notify | Condition | park/unpark |
|---|---|---|---|
| 依赖 | synchronized monitor | Lock/AQS | 无,LockSupport |
| 是否释放锁 | wait 释放 monitor | await 释放 lock | 不涉及锁 |
| 等待集 | 一个 WaitSet | 每个 Condition 一个队列 | 无线程队列,per-thread permit |
| 唤醒 API | notify/notifyAll | signal/signalAll | unpark(Thread) |
| 丢失唤醒 | 可能(通知早于等待) | 可能(signal 早于 await) | 不会(permit 保留) |
| 虚假唤醒 | 有 | 有 | 有 |
| 中断语义 | 抛 InterruptedException | 抛 InterruptedException | 返回并保留中断位 |
| 适用 | 简单 monitor 协作 | 多条件队列 | 实现锁/同步器 |
- 同步器对比:
| 工具 | 语义 | 复用 | 底层 | 典型场景 |
|---|---|---|---|---|
CountDownLatch | 等 N 个事件完成 | 一次性 | AQS 共享 | 启动门、等待依赖就绪 |
CyclicBarrier | 等 N 个线程到齐 | 可复用 | ReentrantLock + Condition | 分阶段并行计算 |
Semaphore | 控制并发许可 | 可复用 | AQS 共享 | 限流、资源池、背压 |
Phaser | 多阶段、动态 parties | 可复用 | 自研 state + QNode | 多阶段任务、动态注册 |
- jstack 线程状态:
| 状态 | 常见原因 | 关注点 |
|---|---|---|
BLOCKED | 等 synchronized monitor | 谁持有锁、锁竞争 |
WAITING | Object.wait、join、park | 等谁 notify/unpark |
TIMED_WAITING | sleep、wait(timeout)、parkNanos | 超时是否合理 |
追问链:
- wait/notify 为什么必须在 synchronized 里? →
wait要释放 monitor、notify要操作 WaitSet,都必须先持有 monitor;否则IllegalMonitorStateException。更重要的是“检查条件 + 进入等待”必须原子,否则会丢失唤醒。 - wait 和 sleep 有什么区别? →
wait是 Object 方法,释放 monitor,需在同步块内,可被 notify 唤醒;sleep是 Thread 方法,不释放锁,时间到自动醒,抛InterruptedException。 - 为什么 wait 要用 while 而不是 if? → 虚假唤醒、被 notify 后条件可能又被其他线程改掉;醒来必须重新检查谓词,
while才能保证条件真正成立。 - notify 和 notifyAll 怎么选? → 只有一个等待条件且确认不会唤醒错对象时可用 notify;多个条件、多个等待者、状态不确定时用 notifyAll,代价是惊群和无效竞争。
- 什么是丢失唤醒? → 通知发生在等待之前,等待者没看到状态变化就进入 wait,之后没人再通知;解决是“同一把锁 + 谓词 + while”,通知前先改状态。
- Condition 和 wait/notify 的区别? → Condition 绑定显式 Lock,一个锁可建多个等待队列,支持公平/超时/不可中断等待;wait/notify 绑定 monitor,只有一个 WaitSet,唤醒不保证公平。
- Condition.await 底层做了什么? → 保存重入计数,
fullyUnlock释放锁,节点入 condition queue,LockSupport.park;被 signal 后转到 sync queue,再重新acquire恢复重入计数。 - signal 时为什么要持有锁?signal 后等待线程能立刻跑吗? →
signal要修改 condition queue,必须持锁;它只把节点转到 sync queue 并 unpark,等待线程还要等 signaler 释放锁后重新竞争,才能从 await 返回。 - 为什么一个 Lock 要支持多个 Condition? → 不同条件分开等待,避免 notifyAll 唤醒无关线程;
ArrayBlockingQueue用notEmpty和notFull分别唤醒生产者和消费者。 - park/unpark 和 wait/notify 的区别? → park 不需要 monitor,permit 可先于 park 保留,不会因通知早到而丢失;但 park 没有等待集、没有公平性,可能虚假唤醒,中断也不抛异常。
- unpark 在 park 之前调用会怎样? → 会设置 permit,下一次 park 立即返回并消费许可;但 permit 不累计,连续多次 unpark 也只相当于一次。
- park 被中断会怎样? → park 直接返回,中断位保留,不抛
InterruptedException;调用方要检查Thread.interrupted()或isInterrupted()并决定退出还是继续。 - CountDownLatch 的原理?能复用吗? → AQS 共享模式,state 是剩余计数;await 在 state != 0 时排队,countDown 用 CAS 递减到 0 时唤醒所有等待者;一次性,不能 reset 或增加计数。
- CountDownLatch 和 CyclicBarrier 的区别? → Latch 等“事件/计数”,一次性的,countDown 方和 await 方可以不同;Barrier 等“线程到齐”,可复用,所有 parties 都必须 await,还能执行 barrier action。
- CyclicBarrier 的超时/中断/异常怎么处理? → 任一等待者超时、被中断,或 barrier action 抛异常,都会 breakBarrier;其他人收到
BrokenBarrierException,需要reset()或重建屏障后重试。 - Semaphore 的公平/非公平有什么区别? → 公平模式在
tryAcquireShared里检查hasQueuedPredecessors,按队列顺序拿许可;非公平允许插队,吞吐更高但可能饥饿。 - Semaphore 的 release 能超过初始许可吗? → 能。Semaphore 不校验 owner,release 只是增加 state;误 release 会让许可膨胀,必须用 try/finally 保证 acquire/release 配对。
- Phaser 和 CyclicBarrier 的区别? → Phaser 支持动态 register/deregister、多阶段、分层和
onAdvance钩子;CyclicBarrier 是固定 parties、单屏障动作、可复用。Phaser 更灵活,但状态和排查更复杂。 - Phaser 的 parties 有什么限制? → parties 占 16 位,上限 65535;
bulkRegister会检查。onAdvance默认在 registeredParties 为 0 时终止。 - 线上线程挂起/死锁怎么排查? → jstack 看
BLOCKED/WAITING/TIMED_WAITING和栈顶的wait、await、park;找谁持有 monitor/lock、谁该 notify/signal/unpark;结合 jcmd、JFR、线程 dump 对比。
- wait/notify 为什么必须在 synchronized 里? →
生产案例/取舍(示例,替换成你的项目):
- 生产者用
if (!empty) wait(),消费者一次唤醒多个,出现虚假唤醒后继续消费空队列;改成while谓词循环,并在同一把锁内修改状态。 - 通知线程先
notify()再设置标志,等待线程错过通知后永久挂起;改成先改状态、再 notify,等待端while检查。 - 多条件场景用
notifyAll唤醒所有线程,吞吐下降;改成两个Condition,生产者和消费者各自等待。 CountDownLatch在任务异常时没有countDown,主线程await永久阻塞;在finally中 countDown,并加超时兜底。CyclicBarrier某个线程超时,整个屏障 broken,其他线程全部异常;捕获BrokenBarrierException后reset()或重建,并减少单次阶段耗时。Semaphore在异常路径漏了release,许可逐渐耗尽;用 try/finally 配对,或封装成资源池。Phaser注册了 parties 但任务结束后没有arriveAndDeregister,phase 永远不推进;在 finally 中注销,或使用onAdvance控制终止。- 取舍:wait/notify 简单但只有一个等待集;Condition 更清晰但代码更长;park 最灵活但最底层;同步器优先用 JUC 现成类,避免手写状态机。
- 生产者用
易错点:
wait/notify没放在synchronized里,直接IllegalMonitorStateException。- 用
if而不是while包wait/await,忽略虚假唤醒。 - 通知前不改变共享状态,或通知和等待用的不是同一把锁,导致丢失唤醒。
- 多个等待条件共用一个 WaitSet,
notify唤醒错对象。 - 认为
notify会释放锁;实际要退出同步块后等待者才能竞争。 Condition.await/signal没持锁,或signal后以为等待线程立刻执行。- 认为
park不会虚假唤醒,或把unpark当计数信号用。 park被中断后不检查中断位,线程“醒来”但没退出。CountDownLatch忘记countDown、以为可以 reset,或await不设超时。CyclicBarrierbroken 后不 reset,继续 await 继续抛异常。Semaphoreacquire/release 不配对,或把Semaphore(1)当可重入锁。Phaser忘记arriveAndDeregister,或onAdvance返回 true 的语义没设计好。
30 秒口述稿:
线程协作分三层:最上面是 CountDownLatch、CyclicBarrier、Semaphore、Phaser 这些同步器;中间是 AQS 的 Condition 和 LockSupport.park/unpark;最下面是 Object 的 wait/notify。wait 必须在 synchronized 里,释放 monitor 进 WaitSet,notify 只是把线程移到入口队列,退出同步块后才能重新竞争;Condition 是 Lock 上的多等待集,await 释放锁、signal 转队列。所有等待都要用 while 谓词,防虚假唤醒和丢失唤醒。Latch 等事件、Barrier 等线程、Semaphore 限并发、Phaser 管多阶段动态 parties。
- 3 分钟展开顺序:结论(三层协作原语)→ wait/notify 与 monitor/WaitSet → 虚假唤醒、丢失唤醒、notifyAll → Condition 的 await/signal 与多等待集 → park/unpark 的 permit 与中断 → CountDownLatch/Semaphore 的 AQS 共享模式 → CyclicBarrier 的 Generation/breakBarrier → Phaser 的 phase/parties/onAdvance → 选型与 jstack 排查 → 生产坑。