Skip to content

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 谓词循环里,处理虚假唤醒、丢失唤醒和中断。

  • 分层要点:

    1. wait/notify 与 monitor:wait/notify/notifyAll 是 Object 上的方法,必须在 synchronized 内调用,否则 IllegalMonitorStateException。wait 原子地释放 monitor 并把线程放入 WaitSet;notify/notifyAll 把等待者从 WaitSet 移到 EntryList,通知线程退出同步块后,等待者重新竞争 monitor。wait 可能虚假唤醒,必须用 while (!condition);notify 先于 wait 会丢失唤醒;notify 只唤醒一个且不保证公平,多个等待条件时容易唤醒错对象。
    2. Condition 与 AQS:Condition 是 Lock 上的“多等待集”,由 lock.newCondition() 创建。await 释放锁(ReentrantLock 会释放全部重入计数)并把节点挂到 condition queue,signal 把节点转到 AQS 的 sync queue,等待者重新竞争锁;signal 本身不释放锁。必须持锁调用 await/signal,否则 IllegalMonitorStateException。一个锁可以建多个 Condition,ArrayBlockingQueue 的 notEmpty/notFull 就是典型。
    3. park/unpark:LockSupport.park/unpark 是最底层阻塞原语,基于每个线程的 permit,permit 是二值的、不累计:多次 unpark 只相当于一次许可,unpark 可以先于 park 调用,许可会保留到下一次 park。park 可能虚假唤醒;被中断时直接返回并保留中断位,不抛 InterruptedException。AQS、Condition、ForkJoinPool 都建立在它上面。
    4. CountDownLatch 与 Semaphore:两者都基于 AQS 共享模式。CountDownLatch 的 state 是剩余计数,await 在 state != 0 时排队,countDown 递减到 0 时唤醒所有等待者;一次性,不能 reset、不能增加计数。Semaphore 的 state 是许可数,acquire 减、release 加,支持公平/非公平;release 不校验 owner,可能超过初始许可;Semaphore(1) 是互斥量但不是可重入锁。
    5. CyclicBarrier:固定 parties 的可复用屏障,内部是 ReentrantLock + Condition + Generation。每个线程 await 递减 count,最后一个到达的线程执行 barrierCommand,然后 nextGeneration 重置 count 并 signalAll;超时、中断或屏障动作异常会 breakBarrier,其他线程收到 BrokenBarrierException,需要 reset() 或重建。await 返回到达序号,最后一个到达者返回 0。
    6. Phaser:多阶段、可动态注册/注销的屏障。state 高位是 phase,中间是 parties,低位是 unarrived;最后到达者推进 phase,调用 onAdvance(phase, parties),返回 true 则终止。支持 arrive、arriveAndAwaitAdvance、arriveAndDeregister、awaitAdvance,支持分层 Phaser;parties 上限 65535。它比 CyclicBarrier 灵活,但状态机和排查更复杂。
    7. 选型与排查:简单 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 判断。
  • 图/流程:

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。
  • wait/notify vs Condition vs park/unpark:

维度wait/notifyConditionpark/unpark
依赖synchronized monitorLock/AQS无,LockSupport
是否释放锁wait 释放 monitorawait 释放 lock不涉及锁
等待集一个 WaitSet每个 Condition 一个队列无线程队列,per-thread permit
唤醒 APInotify/notifyAllsignal/signalAllunpark(Thread)
丢失唤醒可能(通知早于等待)可能(signal 早于 await)不会(permit 保留)
虚假唤醒有有有
中断语义抛 InterruptedException抛 InterruptedException返回并保留中断位
适用简单 monitor 协作多条件队列实现锁/同步器
  • 同步器对比:
工具语义复用底层典型场景
CountDownLatch等 N 个事件完成一次性AQS 共享启动门、等待依赖就绪
CyclicBarrier等 N 个线程到齐可复用ReentrantLock + Condition分阶段并行计算
Semaphore控制并发许可可复用AQS 共享限流、资源池、背压
Phaser多阶段、动态 parties可复用自研 state + QNode多阶段任务、动态注册
  • jstack 线程状态:
状态常见原因关注点
BLOCKED等 synchronized monitor谁持有锁、锁竞争
WAITINGObject.wait、join、park等谁 notify/unpark
TIMED_WAITINGsleep、wait(timeout)、parkNanos超时是否合理
  • 追问链:

    1. wait/notify 为什么必须在 synchronized 里? → wait 要释放 monitor、notify 要操作 WaitSet,都必须先持有 monitor;否则 IllegalMonitorStateException。更重要的是“检查条件 + 进入等待”必须原子,否则会丢失唤醒。
    2. wait 和 sleep 有什么区别? → wait 是 Object 方法,释放 monitor,需在同步块内,可被 notify 唤醒;sleep 是 Thread 方法,不释放锁,时间到自动醒,抛 InterruptedException。
    3. 为什么 wait 要用 while 而不是 if? → 虚假唤醒、被 notify 后条件可能又被其他线程改掉;醒来必须重新检查谓词,while 才能保证条件真正成立。
    4. notify 和 notifyAll 怎么选? → 只有一个等待条件且确认不会唤醒错对象时可用 notify;多个条件、多个等待者、状态不确定时用 notifyAll,代价是惊群和无效竞争。
    5. 什么是丢失唤醒? → 通知发生在等待之前,等待者没看到状态变化就进入 wait,之后没人再通知;解决是“同一把锁 + 谓词 + while”,通知前先改状态。
    6. Condition 和 wait/notify 的区别? → Condition 绑定显式 Lock,一个锁可建多个等待队列,支持公平/超时/不可中断等待;wait/notify 绑定 monitor,只有一个 WaitSet,唤醒不保证公平。
    7. Condition.await 底层做了什么? → 保存重入计数,fullyUnlock 释放锁,节点入 condition queue,LockSupport.park;被 signal 后转到 sync queue,再重新 acquire 恢复重入计数。
    8. signal 时为什么要持有锁?signal 后等待线程能立刻跑吗? → signal 要修改 condition queue,必须持锁;它只把节点转到 sync queue 并 unpark,等待线程还要等 signaler 释放锁后重新竞争,才能从 await 返回。
    9. 为什么一个 Lock 要支持多个 Condition? → 不同条件分开等待,避免 notifyAll 唤醒无关线程;ArrayBlockingQueue 用 notEmpty 和 notFull 分别唤醒生产者和消费者。
    10. park/unpark 和 wait/notify 的区别? → park 不需要 monitor,permit 可先于 park 保留,不会因通知早到而丢失;但 park 没有等待集、没有公平性,可能虚假唤醒,中断也不抛异常。
    11. unpark 在 park 之前调用会怎样? → 会设置 permit,下一次 park 立即返回并消费许可;但 permit 不累计,连续多次 unpark 也只相当于一次。
    12. park 被中断会怎样? → park 直接返回,中断位保留,不抛 InterruptedException;调用方要检查 Thread.interrupted() 或 isInterrupted() 并决定退出还是继续。
    13. CountDownLatch 的原理?能复用吗? → AQS 共享模式,state 是剩余计数;await 在 state != 0 时排队,countDown 用 CAS 递减到 0 时唤醒所有等待者;一次性,不能 reset 或增加计数。
    14. CountDownLatch 和 CyclicBarrier 的区别? → Latch 等“事件/计数”,一次性的,countDown 方和 await 方可以不同;Barrier 等“线程到齐”,可复用,所有 parties 都必须 await,还能执行 barrier action。
    15. CyclicBarrier 的超时/中断/异常怎么处理? → 任一等待者超时、被中断,或 barrier action 抛异常,都会 breakBarrier;其他人收到 BrokenBarrierException,需要 reset() 或重建屏障后重试。
    16. Semaphore 的公平/非公平有什么区别? → 公平模式在 tryAcquireShared 里检查 hasQueuedPredecessors,按队列顺序拿许可;非公平允许插队,吞吐更高但可能饥饿。
    17. Semaphore 的 release 能超过初始许可吗? → 能。Semaphore 不校验 owner,release 只是增加 state;误 release 会让许可膨胀,必须用 try/finally 保证 acquire/release 配对。
    18. Phaser 和 CyclicBarrier 的区别? → Phaser 支持动态 register/deregister、多阶段、分层和 onAdvance 钩子;CyclicBarrier 是固定 parties、单屏障动作、可复用。Phaser 更灵活,但状态和排查更复杂。
    19. Phaser 的 parties 有什么限制? → parties 占 16 位,上限 65535;bulkRegister 会检查。onAdvance 默认在 registeredParties 为 0 时终止。
    20. 线上线程挂起/死锁怎么排查? → jstack 看 BLOCKED/WAITING/TIMED_WAITING 和栈顶的 wait、await、park;找谁持有 monitor/lock、谁该 notify/signal/unpark;结合 jcmd、JFR、线程 dump 对比。
  • 生产案例/取舍(示例,替换成你的项目):

    • 生产者用 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 不设超时。
    • CyclicBarrier broken 后不 reset,继续 await 继续抛异常。
    • Semaphore acquire/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 排查 → 生产坑。