知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 并发工具类:CountDownLatch / CyclicBarrier / Semaphore > 导读:本文从"主线程怎么等一批子任务全部跑完、多个线程怎么在同一个集合点碰头后再一起出发、又怎么把同时访问数据库的线程数卡在上限以内"这三个具体痛点出发,把 CountDownLatch、CyclicBarrier、Semaphore 的定位差异、核心 API、底层原理,以及 Exchanger 的适用场景讲透,最后给出对比表、选型建议与踩坑清单。适合已经会写多线程、但在"这个场景到底该用哪个同步器"上经常犯迷糊的中级 Java 同学。 ## 一、先建立全局认知 ### Q:这三个类放在一起,最容易混淆的点是什么? A:结论先行——它们的本质区别只有一句话:**CountDownLatch 管"等事件",CyclicBarrier 管"等人",Semaphore 管"等资源"。** 先把三个心智模型立住,后面所有 API 都是从这三个模型推导出来的: - **CountDownLatch(倒计时门闩)**:像一个倒计时的闸门。初始化时设定计数 N,每有一个线程完成工作就 `countDown()` 把计数减 1;在闸门另一侧等待的线程调用 `await()`,直到计数归零才被放行。它是**一次性**的——计数到 0 之后就不能重置了。 - **CyclicBarrier(循环屏障)**:像一个集合点。约定好要凑齐 N 个线程,每个线程干完自己那一段就 `await()`,只有当 N 个线程都到齐,大家才一起越过屏障继续往下走。它是**可循环复用**的——越过一次屏障后计数自动重置,可以再来一轮。 - **Semaphore(信号量)**:像一组通行证(许可,permit)。初始化时发放 M 张通行证,线程要访问受保护资源先去 `acquire()` 拿一张,用完 `release()` 还回去;没有通行证的线程只能排队等。它不关心线程之间"合作完成某个任务",只关心**同时最多有多少个线程能进入某个临界区**。 一句话对照记:  *图:并发工具类:CountDownLatch / CyclicBarrier / Semaphore 语义对比* ```text CountDownLatch:N 个线程各自报"我做完了" → 别人可以继续 (等事件完成) CyclicBarrier :N 个线程互相等"你到了吗" → 一起继续 (等人到齐) Semaphore :最多 M 个线程能同时"进门" → 其余排队 (等资源许可) ``` ### Q:为什么它们能被统称为"同步器"?底层靠什么实现? A:结论先行——它们都是**同步器(Synchronizer)**,即"用一套统一的排队/唤醒机制协调多个线程状态"的工具,底层大多建立在 **AQS(AbstractQueuedSynchronizer,抽象队列同步器)** 之上。 AQS 的核心只有两样东西: 1. 一个 `volatile int state`,表示同步状态; 2. 一个 CLH 双向队列,存放获取不到状态而排队的线程。 不同同步器只是给 `state` 赋予了不同含义: | 同步器 | `state` 的含义 | 获取/释放语义 | |---|---|---| | CountDownLatch | 剩余计数 | `countDown()` 递减,归零时唤醒所有 `await()` 者 | | Semaphore | 当前可用许可数 | `acquire()` 递减,`release()` 递增 | | CyclicBarrier | 不直接用 AQS,内部用 ReentrantLock + Condition + `count` 计数 | 每来一个线程 `count--`,归零触发 barrierAction 并唤醒所有等待者 | 注意 CyclicBarrier 是个例外:它**不是基于 AQS 实现的**,而是用 `ReentrantLock` 加一个 `Condition`(在源码里叫 `trip`)配合一个 `int count` 完成的。这个细节在面试里常常是加分项。理解这一点,也能解释为什么 CyclicBarrier 有 `reset()` 而 CountDownLatch 没有——前者的计数是普通字段,可以人为重置;后者的 `state` 是 AQS 状态,归零后语义上就"完成"了。 **为什么这么设计?** 因为把"状态量 + 排队 + 唤醒"抽象出来后,一堆同步器就不用各自造轮子。代价是 AQS 的 `state` 语义一旦确定就固定了,所以 CountDownLatch 天生不可复用;而 CyclicBarrier 干脆绕开 AQS,自己控制计数,才换来了可循环的能力。这正是"设计取舍":复用的灵活性 vs 统一框架的简洁性。 ## 二、CountDownLatch:一次性倒计时门闩 ### Q:CountDownLatch 的核心 API 和语义是什么? A:结论先行——它只有 4 个常用方法,语义极其简单:`await()` 阻塞等计数归零,`countDown()` 让计数减 1。 ```java // CountDownLatch 常用 API(JDK 官方签名) CountDownLatch latch = new CountDownLatch(3); // 初始计数 3 latch.countDown(); // 计数 -1(减到 0 后不再变化) latch.await(); // 阻塞直到计数为 0;可被中断,抛 InterruptedException latch.await(2, TimeUnit.SECONDS); // 带超时:归零返回 true,超时返回 false latch.getCount(); // 返回当前剩余计数 ``` 关键点与预期行为: - `countDown()` 递减到 0 之后**不会变成负数**,多次调用也没有副作用;当计数从 1 减到 0 的那一刻,所有阻塞在 `await()` 的线程会被唤醒。 - `await()` 返回后并不代表任务"成功",它只代表**计数归零**。如果某个子任务抛异常后仍然 `countDown()` 了(这在 `finally` 里很常见),主线程会以为"它做完了"。所以真正要判断结果,得把子任务结果/异常单独收集,不能靠 `await()`。 - `await()` 声明了受检异常 `InterruptedException`,必须处理;生产中推荐用带超时的重载,避免主线程被永久挂住。 ### Q:典型用法一:并行任务汇总,怎么做才不会出错? A:结论先行——**用 `countDown()` 放在 `finally` 里,保证异常路径也减计数;用带超时的 `await()` 兜底;用共享容器收集子任务结果,而不是指望 `await()` 返回"成功"。** 下面是一个可运行示例:把 3 个远程查询并行发起,主线程等全部完成后再汇总耗时。 ```java import java.util.concurrent.*; public class ParallelAggregateDemo { public static void main(String[] args) throws InterruptedException { int taskCount = 3; CountDownLatch latch = new CountDownLatch(taskCount); // 用线程安全的容器收集结果(此处只演示计数,结果用 ConcurrentHashMap) ConcurrentHashMap<String, String> results = new ConcurrentHashMap<>(); ExecutorService pool = Executors.newFixedThreadPool(taskCount); long start = System.currentTimeMillis(); for (int i = 0; i < taskCount; i++) { final String taskName = "task-" + i; pool.execute(() -> { try { String data = remoteQuery(taskName); // 模拟远程调用 results.put(taskName, data); } catch (Exception e) { results.put(taskName, "ERROR: " + e.getMessage()); } finally { latch.countDown(); // 关键:无论成败都要减计数 } }); } // 主线程最多等 3 秒,避免被某个卡死的子任务拖死 boolean done = latch.await(3, TimeUnit.SECONDS); long cost = System.currentTimeMillis() - start; System.out.println("allDone=" + done + ", remaining=" + latch.getCount() + ", cost=" + cost + "ms"); System.out.println("results=" + results); pool.shutdown(); } // 模拟一次耗时 300ms 的远程查询 private static String remoteQuery(String name) throws InterruptedException { Thread.sleep(300); return name + "-data"; } } ``` 预期行为:3 个任务并行执行,总耗时接近单次 300ms 而不是 900ms;`allDone=true`、`remaining=0`。如果把某个 `remoteQuery` 改成抛异常,`finally` 里的 `countDown()` 仍然会执行,主线程不会卡死,`results` 里会记录 `ERROR: ...`。 适用与不适用: - 适用:主线程(或某个协调线程)需要"等一批并行任务全部结束"才能继续,典型如**并行查询后汇总、批量导入后统一提交、压测并发打点**。 - 不适用:需要"循环复用同一套等待逻辑"(例如每处理一批就等一次)——CountDownLatch 不能重置,每批都得 new 一个,或者改用 CyclicBarrier。 ### Q:典型用法二:服务启动前置检查,怎么用? A:结论先行——用一个初始计数为 1 的 `CountDownLatch` 当"发令枪/开关":所有工作线程先 `await()` 挂起,等前置检查线程完成检查后 `countDown()`,工作线程被一次性全部放行。 这种用法和上面的方向刚好相反:上面是"一个线程等 N 个线程",这里变成"**N 个线程等一个线程的信号**"。 ```java import java.util.concurrent.*; public class StartupGateDemo { public static void main(String[] args) throws InterruptedException { // 计数为 1:只等一次信号 CountDownLatch readyGate = new CountDownLatch(1); ExecutorService pool = Executors.newFixedThreadPool(4); for (int i = 0; i < 4; i++) { final int workerId = i; pool.execute(() -> { try { readyGate.await(); // 全部工作线程在此等待"放行" System.out.println("worker-" + workerId + " 开始处理业务"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); } // 前置依赖检查(配置加载、缓存预热、DB 探活等) boolean ready = checkDependencies(); System.out.println("前置检查结果=" + ready); readyGate.countDown(); // 放行所有工作线程 Thread.sleep(200); pool.shutdown(); } private static boolean checkDependencies() throws InterruptedException { Thread.sleep(500); // 模拟检查耗时 return true; } } ``` 关键点:`readyGate` 只 `countDown()` 一次,之后所有 `await()` 的线程都被放行,且新来的线程调用 `await()` 会**立即返回**(因为计数已经是 0)。所以它同时兼具"一次性开关"和"并行启动"的能力——这正是接口压测里常用的"**并发压测发令枪**"套路。 不适用场景:如果检查失败需要让工作线程"别启动",靠 latch 只能控制"放行时机",控制不了"放行或取消"这个二选一。此时可以配合一个 `volatile boolean` 标志位,放行后再判断标志位决定是否继续。 ### Q:为什么说 CountDownLatch 是一次性的?能不能复用? A:结论先行——不能复用。计数归零后,`await()` 会永久立即返回,`countDown()` 对 0 无影响,`state` 也无法被重置,因为 AQS 没有对外开放重置入口。 如果业务确实需要"反复等同一批任务",有两条路: 1. 每轮 `new CountDownLatch(n)`,用局部变量持有,不要做成成员变量复用; 2. 改用 **CyclicBarrier**,它天生为"循环"设计。 **这是选型里最常见的坑之一**:把 latch 写成 `static` 成员,第一轮用完归零,第二轮 `await()` 直接穿透,等待逻辑静默失效——不报错、不阻塞,但结果全错。这类 Bug 在联调阶段很难发现,因为"线程没卡住"看起来像是好事。 ### Q:CountDownLatch 底层用的"共享模式"是怎么回事?它和 Thread.join() 有什么区别? A:结论先行——CountDownLatch 走的是 AQS 的**共享模式(Shared)**:多个线程可以同时在 `await()` 上等待同一份状态,计数归零时被**一次性全部唤醒**。它与 `Thread.join()` 的核心差别是"等谁、等几个"。 AQS 把同步分成两种模式: - **独占模式(Exclusive)**:同一时刻只能一个线程持有,如 ReentrantLock、ReentrantReadWriteLock 的写锁; - **共享模式(Shared)**:同一时刻允许多个线程共同等待/持有,如 CountDownLatch、Semaphore。 CountDownLatch 内部覆写了两个关键方法: - `tryAcquireShared(int acquires)`:返回 `getState() == 0 ? 1 : -1`,即"计数是否已归零",归零表示可以通行; - `tryReleaseShared(int releases)`:用 CAS 循环把 `state` 减 1,返回 `state == 0`(表示是否触发唤醒)。 `await()` 底层调用 `acquireSharedInterruptibly(1)`:计数不为 0 就把当前线程入队并 `park` 挂起。`countDown()` 调用 `releaseShared(1)`:当 `state` 归零时,AQS 会把等待队列中的**所有**共享等待者一起唤醒。这正是共享模式与独占模式最大的区别——独占模式释放时只唤醒一个后继节点,共享模式会级联唤醒全部。 和 `Thread.join()` 的对比: | 维度 | `Thread.join()` | `CountDownLatch.await()` | |---|---|---| | 等待对象 | 一个具体的线程对象 | 一个计数(可对应多个线程/事件) | | 等待数量 | 等几个线程就要 join 几次 | 一个 latch 可等 N 个事件 | | 计数归属 | 绑定线程生命周期 | 与线程解耦,可一对多、多对一 | | 完成含义 | 该线程已终止 | 计数归零(不代表任务成功) | **为什么用 latch 而不是 join?** 因为 join 绑定的是"线程生命周期",一个线程只能减一次(自己结束),而 latch 绑定的是"计数事件":一个线程可以负责多个子任务、`countDown()` 多次,也可以多个线程减同一个 latch。这种"解耦"正是它比 join 灵活的地方——协调的是"事情做没做完",而不是"线程死没死"。 ## 三、CyclicBarrier:可循环的集合点 ### Q:CyclicBarrier 的核心 API 和"循环"到底指什么? A:结论先行——`CyclicBarrier` 让 N 个线程互相等待,**最后一个到达的线程**负责唤醒其余所有线程;越过屏障后计数自动重置,因此可以反复使用,"循环"就是自动重置的意思。 ```java // CyclicBarrier 常用 API(JDK 官方签名) CyclicBarrier barrier = new CyclicBarrier(3); // 3 方参与 CyclicBarrier barrier2 = new CyclicBarrier(3, action); // 到达后先执行 action int idx = barrier.await(); // 阻塞,返回本线程到达的序号(从 parties-1 递减到 0) int idx2 = barrier.await(1, TimeUnit.SECONDS); // 带超时 int parties = barrier.getParties(); // 参与方数量(构造时固定) int waiting = barrier.getNumberWaiting(); // 当前已在等待的线程数 boolean broken = barrier.isBroken(); // 屏障是否已损坏 barrier.reset(); // 重置屏障 ``` 三者之间最直观的差异,用一张 ASCII 图对比: ```text CountDownLatch(一次性,单向放行) T1 --countDown-->\ T2 --countDown----> [计数 3→0] ==> 主线程 await() 放行 之后归零不可复用 T3 --countDown-->/ CyclicBarrier(可循环,互相等待) T1 --await-->\ T2 --await----> [到齐 3/3] ==> 触发 action,3 个线程一起继续 T3 --await-->/ ↓ 计数自动重置,可再来一轮 Semaphore(许可制,控制并发度) T1..Tn --> acquire() 抢许可 --> [许可池 M 张] --> 抢到的进入临界区 用完 release() 归还,等待者补位 ``` ### Q:barrierAction 什么时候执行?由哪个线程执行? A:结论先行——**barrierAction 在"最后一个线程到达、屏障被触发"时执行,且由这个最后到达的线程执行**,而不是另起一个线程或由第一个到达者执行。 因为是由最后一个到达的线程执行,所以 barrierAction 里**不要写太耗时的逻辑**:它会把整个集合点再拖住,其他 N-1 个线程会一直等到它跑完才被放行。通常只放"阶段切换的轻量动作",比如打印阶段日志、切换共享上下文、更新进度。 ```java import java.util.concurrent.*; public class CyclicBarrierPhasesDemo { public static void main(String[] args) { int parties = 3; // 到达屏障后、放行前执行的轻量动作 CyclicBarrier barrier = new CyclicBarrier(parties, () -> { System.out.println("[barrier] 全员到齐,进入下一阶段。触发线程=" + Thread.currentThread().getName()); }); ExecutorService pool = Executors.newFixedThreadPool(parties); for (int i = 0; i < parties; i++) { final int id = i; pool.execute(() -> { try { // 阶段一 work("阶段一", id); int idx = barrier.await(); System.out.println("worker-" + id + " 越障,返回序号=" + idx); // 阶段二(可循环复用同一个 barrier) work("阶段二", id); barrier.await(); System.out.println("worker-" + id + " 全部阶段完成"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } catch (BrokenBarrierException e) { System.err.println("worker-" + id + " 屏障已损坏,放弃本轮: " + e); } }); } pool.shutdown(); } private static void work(String phase, int id) throws InterruptedException { Thread.sleep(100L * (id + 1)); // 故意让各线程耗时不同 System.out.println("worker-" + id + " 完成 " + phase); } } ``` 预期行为:`阶段一` 各线程完成时间不同,但都会被 `barrier.await()` 拦住,直到 3 个都到齐才打印 `[barrier] 全员到齐` 并一起进入阶段二;`await()` 的返回值在同一轮里是唯一的(最后一个到达者拿到 0,第一个到达者拿到 parties-1)。同一个 `barrier` 对象被用了两次,第二轮会自动重置计数——这就是"循环"。 ### Q:什么是 BrokenBarrierException 和 broken 状态? A:结论先行——当屏障被**提前破坏**时,屏障进入 broken(损坏)状态,此时除了触发破坏的那个线程会收到真实异常,其余正在等待的线程都会收到 `BrokenBarrierException`。破坏的原因主要有三个:某个等待线程被中断、某个等待线程 `await` 超时、有人调用了 `reset()`。 这是 CyclicBarrier 用起来最容易出线上问题的地方,必须把异常语义吃透: | 触发场景 | 触发者收到的异常 | 其他等待者收到的异常 | 后续状态 | |---|---|---|---| | 某线程 `await()` 被 `interrupt()` | `InterruptedException` | `BrokenBarrierException` | broken,需 `reset()` 才能继续 | | 某线程 `await(timeout)` 超时 | `TimeoutException` | `BrokenBarrierException` | broken | | 有人调用 `reset()` | — | `BrokenBarrierException` | 重置为可用 | | barrierAction 抛异常 | 该异常 | `BrokenBarrierException` | broken | **为什么这么设计?** 因为屏障的语义前提是"全员必须到齐才能继续"。一旦有一方退出(被中断/超时),这个前提就被打破了,让其余线程继续等下去只会永久挂起,所以设计上选择"快速失败"——把所有等待者唤醒并告知"这轮不算数"。这是典型的 fail-fast 取舍:**牺牲自动恢复,换取不会静默死等**。 因此,**使用 CyclicBarrier 必须捕获 `BrokenBarrierException`**,并想清楚"这轮作废后怎么办"。常见处理有两种: 1. 若希望自动续跑,在异常分支里调用 `barrier.reset()` 重新开始一轮(注意并发下 reset 本身也会让等待者收到 BrokenBarrierException,需要配合重试逻辑); 2. 若这是一次性批处理,直接向上抛出、记录日志、终止本轮。 ```java // 带超时 + 异常处理的生产写法骨架 try { barrier.await(5, TimeUnit.SECONDS); } catch (TimeoutException e) { // 本线程超时:本人超时会把屏障置为 broken,其他等待者会收到 BrokenBarrierException barrier.reset(); // 如需继续,重置后再重试这一轮 } catch (BrokenBarrierException e) { // 其他线程把屏障弄坏了,本线程放弃本轮 } catch (InterruptedException e) { Thread.currentThread().interrupt(); // 恢复中断标志,交还上层处理 barrier.reset(); // 避免把其他线程一起困住 } ``` ### Q:CyclicBarrier 和 CountDownLatch 到底怎么选? A:结论先行——**看"计数会不会归零后还要用来等下一轮",以及"参与方是不是互相等"**。 - 需要反复多轮集合(如多阶段流水线、迭代计算、分片处理每轮同步):选 CyclicBarrier。 - 一方等另一方完成、且只等一次(主线程等子任务、启动放行):选 CountDownLatch。 - 注意 CyclicBarrier 是"参与方互相等待",连等待者自己也要 `await()`;CountDownLatch 里"等的人"和"报数的人"可以是两拨完全不同的线程,甚至可以完全不重叠。 还有一个反直觉的点:**CountDownLatch 的 `await()` 者不需要 `countDown()`,CyclicBarrier 的每个参与者通常既等待也被等待**。搞混这一点,就会写出"主线程也去 `barrier.await()` 但参与者又各自等待"导致死不凑数的 Bug。 ## 四、Semaphore:许可制限流 ### Q:Semaphore 的核心 API 和"许可"是什么意思? A:结论先行——Semaphore 内部维护一个许可计数 `state`,`acquire()` 抢许可(不够就排队),`release()` 归还许可,**它限制的是"同一时刻能进入临界区的线程数量",而不是谁先谁后完成**。 ```java // Semaphore 常用 API(JDK 官方签名) Semaphore sem = new Semaphore(5); // 5 个许可,默认非公平 Semaphore fair = new Semaphore(5, true); // 公平模式:按排队顺序分配 sem.acquire(); // 拿 1 个许可,不够则阻塞(可中断) sem.acquire(2); // 一次拿 2 个许可 sem.tryAcquire(); // 立即尝试,拿到 true / 拿不到 false(不阻塞) sem.tryAcquire(1, TimeUnit.SECONDS); // 限时尝试,超时返回 false sem.release(); // 归还 1 个许可 sem.release(2); // 归还 2 个 sem.availablePermits(); // 当前可用许可数 sem.isFair(); // 是否公平模式 ``` 三个必须记住的语义: 1. **许可是"计数"而不是"绑线程"**:和锁不一样,Semaphore 不记录"许可被哪个线程持有"。A 线程 `acquire()`,B 线程也能 `release()`,只要总数对得上就合法。这既是灵活性,也是 `release` 泄满/泄漏的根源。 2. **`release()` 不会校验上限**:如果你在没 `acquire()` 的情况下 `release()`,许可数会**超过初始值**,导致"限流形同虚设"。这一点和锁的"谁加锁谁解锁"完全不同。 3. **`acquire()` 的阻塞可被中断**,也会抛 `InterruptedException`,必须处理。 ### Q:怎么用 Semaphore 做限流和资源池? A:结论先行——**限流就是"把许可数设成允许的并发上限",资源池就是"许可数等于池里资源个数"**;两者的共同点是"进入前 acquire,退出时 finally release"。 下面这个例子用一个 `Semaphore(3)` 把并发访问下游接口的线程数限制在 3,并用 `tryAcquire` 超时快速失败,避免慢调用把线程池拖垮。 ```java import java.util.concurrent.*; public class RateLimitDemo { // 最多 3 个线程同时访问下游 private static final Semaphore PERMITS = new Semaphore(3); public static void main(String[] args) { ExecutorService pool = Executors.newFixedThreadPool(10); // 提交 10 个任务 for (int i = 0; i < 10; i++) { final int id = i; pool.execute(() -> { boolean acquired = false; try { // 最多等 500ms,等不到就降级,避免请求线程堆积 acquired = PERMITS.tryAcquire(500, TimeUnit.MILLISECONDS); if (!acquired) { System.out.println("req-" + id + " 获取许可失败,走降级"); return; } callDownstream(id); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { if (acquired) { PERMITS.release(); // 配对释放,必须放在 finally } } }); } pool.shutdown(); } private static void callDownstream(int id) throws InterruptedException { System.out.println("req-" + id + " 开始调用,可用许可=" + PERMITS.availablePermits()); Thread.sleep(300); // 模拟下游耗时 System.out.println("req-" + id + " 调用结束"); } } ``` 关键点: - 用 `tryAcquire(timeout)` 而不是无限 `acquire()`,让"抢不到许可"变成一次可观测的**降级/快速失败**,而不是无限等待。 - `release()` 放在 `finally`,并用 `acquired` 标志判断——**没拿到许可就绝不能 release**,否则会凭空多出许可。 - 资源池场景同理:`acquire()` 拿到的是"一个连接/一个缓冲区"的使用权,`release()` 是"还回去"。与阻塞队列实现的对象池相比,Semaphore 更轻量,但不保证资源本身的健康检查——`release` 前要确认资源是可复用的。 ### Q:用 Semaphore 实现一个简单资源池,要注意哪些异常路径? A:结论先行——**许可数 = 池容量,`acquire()` 相当于"借出"、`release()` 相当于"归还"**;但 Semaphore 只管"数量"不管"质量",资源失效要在借出/归还时自己校验,且**任何异常路径都必须把许可还回去**。 ```java import java.util.concurrent.*; public class SimplePool<T> { public interface Factory<T> { T create(); } public interface Validator<T> { boolean isValid(T t); } private final Semaphore permits; private final BlockingQueue<T> idle; // 空闲资源 private final Factory<T> factory; private final Validator<T> validator; public SimplePool(int size, Factory<T> factory, Validator<T> validator) { this.permits = new Semaphore(size); // 许可数 = 池容量 this.idle = new LinkedBlockingQueue<>(size); this.factory = factory; this.validator = validator; for (int i = 0; i < size; i++) { idle.offer(factory.create()); // 预热,避免首次借出时同步创建 } } public T borrow() throws InterruptedException { permits.acquire(); // 先拿许可,拿不到就排队 try { T t = idle.poll(); if (t == null || !validator.isValid(t)) { t = factory.create(); // 空闲耗尽或资源失效,重建 } return t; } catch (RuntimeException e) { permits.release(); // 创建失败:许可必须还回去,否则泄漏 throw e; } } public void giveBack(T t) { if (t == null) return; if (validator.isValid(t)) { idle.offer(t); // 健康资源放回空闲队列 } // 失效资源直接丢弃,不还回 idle permits.release(); // 无论资源是否保留,许可都要还 } } ``` 关键点与边界: - **预热 vs 懒加载**:上面预热了 size 个资源;若资源创建很贵、又不是马上全用,可改懒加载,但要防"首次并发借出"时的创建风暴。 - **失效资源的处理**:`borrow` 时校验、`giveBack` 时丢弃失效资源,否则会借出坏资源。Semaphore 本身完全不感知资源状态。 - **异常路径必须归还许可**:`borrow` 里若 `create()` 抛异常,许可已被 `acquire` 过,必须在 `catch` 里 `release`,否则许可泄漏、池子越用越小。 - **`giveBack` 的 `release` 放最后**:无论资源是否保留,只要 `acquire` 发生过就必须 `release`,两者必须严格配对。 - **不适用**:需要"借出超时自动回收""资源健康度监控""许可与资源强绑定"的场景,应该用成熟对象池(如 Apache Commons Pool),自己用 Semaphore 拼很容易在异常分支上漏释放。 ### Q:公平性怎么选?acquire / release 怎么保证配对? A:结论先行——**默认用非公平**(吞吐更高);只有在"严格要求先来先得、避免长任务饥饿"时才开公平。**acquire 与 release 必须严格配对**,且 `release` 必须放在 `finally`。 公平性对比(`new Semaphore(n, true)` 为公平): | 模式 | 行为 | 吞吐 | 风险 | |---|---|---|---| | 非公平(默认) | 新线程可与队首线程竞争,可能"插队" | 更高 | 极端情况下等待久的线程可能饥饿 | | 公平 | 严格按 `acquire` 的排队顺序分配 | 略低(线程切换/排队开销) | 无饥饿,但整体慢一点 | 关于配对,最常见的两类 Bug: 1. **漏 release(许可泄漏)**:某条路径 return/抛异常前没释放,许可数越来越少,最终 `acquire` 永远拿不到,整条链路**假死**。对策:`release` 一定放 `finally`,并用 `acquired` 标志防重复释放。 2. **多 release(许可泄满)**:重复 `release` 或没 `acquire` 就 `release`,许可数超过初始值,限流被架空。对策:不在异常分支里重复释放;如果资源来自外部,用一个明确的 `boolean` 记录"我是否持有",只在为 true 时释放并置 false。 **为什么 Semaphore 不做"持有者校验"?** 因为它的设计目标是"通用的许可计数",不绑定线程身份,才能支持 `acquire` 与 `release` 跨线程、跨方法的灵活用法(例如异步回调里归还许可)。代价就是**配对正确性完全由使用者负责**——这正是它最容易出事的地方。 ## 五、Exchanger、对比表与选型 ### Q:Exchanger 适用于什么场景? A:结论先行——**Exchanger 只在"两个线程之间成对交换数据"时使用**,比如生产者线程和消费者线程互换各自的缓冲区(一个装满数据去换一个空缓冲区)。它是两方(严格两个线程)的交换点。 ```java import java.util.concurrent.*; public class ExchangerDemo { public static void main(String[] args) { Exchanger<String> exchanger = new Exchanger<>(); ExecutorService pool = Executors.newFixedThreadPool(2); // 生产者:准备一批数据,去交换点换回结果 pool.execute(() -> { try { String newBuffer = "produced-batch"; String result = exchanger.exchange(newBuffer); // 阻塞,等另一个线程来换 System.out.println("生产者换回了:" + result); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); // 消费者:处理完上一批,拿空缓冲区去换新数据 pool.execute(() -> { try { Thread.sleep(200); String emptyBuffer = "consumed-done"; String got = exchanger.exchange(emptyBuffer); System.out.println("消费者换到了:" + got); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); pool.shutdown(); } } ``` 关键点与注意事项: - `exchange(V x)` 会**阻塞直到另一个线程也调用 `exchange`**,然后双方各自拿到对方的入参并返回。 - 必须**恰好两个线程**参与,多一个或少一个都会让交换无法配对(第三个线程会一直等)。因此它不适合作为通用限流/集合工具。 - 同样提供带超时的重载 `exchange(V x, long timeout, TimeUnit unit)`,超时抛 `TimeoutException`。 - 典型场景:双缓冲(double buffering)流水线——一边填缓冲、一边读缓冲,填满/读空时互换。业务里不常见,但面试常问,理解它能帮你把"同步器 = 协调线程状态"这个模型补完整。 ### Q:一张表把三者(含 Exchanger)对比清楚? A:结论先行——从"等什么、能否复用、触发后行为、异常类型、典型场景"五个维度对比即可: | 维度 | CountDownLatch | CyclicBarrier | Semaphore | Exchanger | |---|---|---|---|---| | 核心作用 | 等 N 个事件完成 | 等 N 方到齐 | 限制并发数 / 管资源 | 两线程交换数据 | | 计数语义 | 剩余计数,单向减到 0 | 已到方数,到齐即重置 | 可用许可数,可增可减 | 无计数,成对配对 | | 是否可复用 | 不可(一次性) | 可(自动循环) | 可(许可回收后继续) | 可(每次交换一次) | | 触发后行为 | 唤醒所有 `await()` 者 | 触发 barrierAction,一起放行 | 允许后续 `acquire` 者进入 | 双方互换返回值 | | 参与方关系 | 等待方可与报数方不同 | 各方互相等待 | 各取各的许可,互不知情 | 严格两方配对 | | 主要异常 | `InterruptedException` | `InterruptedException`/`BrokenBarrierException`/`TimeoutException` | `InterruptedException` | `InterruptedException`/`TimeoutException` | | 底层 | AQS 共享模式 | ReentrantLock + Condition | AQS 共享模式 | 内部 `Node` + CAS/Lock | | 计数方向 | 递减 | 到达计数 | 递减/递增 | — | | 典型场景 | 主线程等子任务、启动放行、压测发令枪 | 多阶段并行、迭代计算、分片每轮同步 | 下游限流、连接池/对象池 | 双缓冲交接 | ### Q:生产选型建议与踩坑清单? A:结论先行——**选型看"等什么",实现看"配对与超时"**。下面按"症状 → 原因 → 对策"给出最值得记的几条。 选型建议: - **一等多、只等一次、等完成** → CountDownLatch。 - **多方互相等、要循环复用、需要阶段回调** → CyclicBarrier。 - **只想控制"同时几个线程能进来"** → Semaphore。 - 需要"两个线程换数据" → Exchanger。 - 如果只是"等一批 Future 结果",优先考虑 `CompletableFuture.allOf`,比手工 CountDownLatch 更简洁、异常语义更清晰。 踩坑清单: 1. **`await()` 不设超时**:只要有一个子任务永远不返回、或忘记 `countDown()`,调用方线程会**永久阻塞**,在线程池里就是线程被吞。对策:一律用 `await(timeout, unit)`,超时后记录日志并走降级。 2. **`countDown()` 不在 `finally`**:子任务抛异常导致计数永远减不到 0,`await()` 死等。对策:`countDown()` 必须放 `finally`。 3. **把 CountDownLatch 当可复用工具**:第二轮 `await()` 直接穿透,等待逻辑静默失效。对策:要么每轮 `new`,要么改用 CyclicBarrier。 4. **CyclicBarrier 某一方被中断/超时 → 全员 `BrokenBarrierException`**:只写 `catch (InterruptedException)` 不写 `BrokenBarrierException`,会漏掉一批异常线程。对策:三个异常(外加 `TimeoutException`)都要处理,并明确"broken 之后是否 `reset()` 重试"。 5. **barrierAction 里做重活**:它由最后一个到达的线程执行,会把所有等待者一起拖住。对策:barrierAction 只做轻量切换,重活放放行之后。 6. **Semaphore 漏 release → 许可泄漏 → 假死**:对策:`release()` 放 `finally`,用标志位防止释放未获取的许可、防止重复释放。 7. **Semaphore 多 release → 许可超过初始值 → 限流失效**:对策:同一处 `acquire` 对应同一处 `release`,别在多条异常分支里都写 `release`。 8. **公平性误用**:默认非公平吞吐更高;无脑开公平会损失性能。只有在"防饥饿"诉求明确时才开公平。 9. **用 Semaphore 代替线程池**:Semaphore 只控制"并发度",不管理线程生命周期、不提供队列与拒绝策略。要资源隔离和可观测性,还是用独立线程池(同时可把线程数设成并发上限)。 ## 小结 一句话记住三个门:**Latch 等事件(一次性、计数归零放行)、Barrier 等人齐(可循环、到齐一起走、坏了会吵醒所有人)、Semaphore 等许可(控制并发度、acquire/release 必须配对)**;Exchanger 是两线程互换数据的特例。 工程上把三句话变成习惯: - 所有 `await()` 都带超时; - 所有 `countDown()` / `release()` 都进 `finally`,且配对; - 所有 CyclicBarrier 的使用都同时处理 `BrokenBarrierException` 与 `TimeoutException`,并想清楚"坏了之后要不要 reset 重试"。 ## 思考题 1. 用 `CountDownLatch` 写"主线程等 5 个子任务完成",某个子任务忘记 `countDown()`,主线程会有什么表现?如果换成带超时的 `await`,你能观察到什么现象、如何定位? 2. `CyclicBarrier(3)` 在第二轮时,某个线程调用了 `barrier.reset()`,此刻另一个线程正好在 `await()`——它会收到什么异常?broken 之后如何让这组线程安全地再来一轮? 3. 一个下游接口要求并发不超过 20,但你的线程池有 200 个线程。用 Semaphore 应该把许可数设成多少?为什么不是 200?如果下游偶发慢调用,你会用 `acquire()` 还是 `tryAcquire(timeout)`,理由是什么? 4. 为什么 `Semaphore.release()` 允许在没 `acquire()` 的情况下调用?这个设计带来了什么便利,又埋了哪些坑?请举出"许可超过初始值"的具体代码路径。 5. 同样是"等一批任务完成",`CompletableFuture.allOf` 和 `CountDownLatch` 在**异常处理**和**代码可读性**上有什么差别?什么场景下你会放弃 CountDownLatch 改用 `allOf`?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入