当前位置：首页 > news >正文

java并发包下CountDownLatch、Semaphore用法

news 2025/7/11 9:17:58

CountDownLatch：
倒计时器：让一个线程等待其他多个线程完成后再执行。
原理：初始化一个计数器，线程完成任务后调用countDown()减 1，等待线程调用await()阻塞，直到计数器为 0。
案例1：主线程等待 5 个任务线程完成：

    public static void main(String[] args) throws Exception{log.info("主线程开始");CountDownLatch latch = new CountDownLatch(5);for (int i = 0; i < 5; i++) {int finalI = i;new Thread(() -> {// 执行任务async(finalI);latch.countDown(); // 完成后计数器减1}).start();}latch.await(); // 主线程等待，直到计数器为0log.info("异步线程都执行完毕了");}public static void async(Integer i){try {Thread.sleep(5000l);} catch (InterruptedException e) {throw new RuntimeException(e);}//System.out.println("我是异步线程"+i);log.info("我是异步线程:{}",i);}

打印结果如下， latch.await() 方法会阻塞，一直等待子线程执行完毕后，才会执行主线程方法。

10:11:24.790 [main] INFO com.xxxx - 主线程开始
10:11:29.847 [Thread-4] INFO com.xxxx - 我是异步线程:4
10:11:29.847 [Thread-2] INFO com.xxxx - 我是异步线程:2
10:11:29.847 [Thread-3] INFO com.xxxx - 我是异步线程:3
10:11:29.847 [Thread-1] INFO com.xxxx - 我是异步线程:1
10:11:29.847 [Thread-0] INFO com.xxxx - 我是异步线程:0
10:11:29.852 [main] INFO com.xxxx - 异步线程都执行完毕了

案例2：主线程等待5个子线程的同时设置超时时间，过了超时时间后，不管子线程是否都执行完毕，都要执行主线程任务

    public static void main(String[] args) throws Exception{log.info("主线程开始");CountDownLatch latch = new CountDownLatch(5);for (int i = 0; i < 5; i++) {int finalI = i;new Thread(() -> {// 执行任务async(finalI);latch.countDown(); // 完成后计数器减1}).start();}//CountDownLatch 的 await(long timeout, TimeUnit unit) 方法用于等待计数器归零，//但会设置最大等待时间。其返回值 boolean 表示计数器是否在超时前归零，具体含义如下：//true：计数器在超时时间内归零，说明所有任务已完成。//false：超时时间已过，但计数器仍未归零，说明部分任务未完成。boolean await = latch.await(1, TimeUnit.SECONDS);log.info("异步线程都执行完毕了:{}",await);}public static void async(Integer i){try {Thread.sleep(5000l);} catch (InterruptedException e) {throw new RuntimeException(e);}//System.out.println("我是异步线程"+i);log.info("我是异步线程:{}",i);}

打印结果如下：从代码中可以看出，我主线程设置等待时间为1s（子线程设置休眠时间5s，所以在1s后子线程还没有执行完成，所以await变量返回false，开始执行主线程下面的代码）

10:19:53.117 [main] INFO com.xxxx - 主线程开始
10:19:54.173 [main] INFO com.xxxx - 异步线程都执行完毕了:false
10:19:58.170 [Thread-2] INFO com.xxxx - 我是异步线程:2
10:19:58.170 [Thread-0] INFO com.xxxx - 我是异步线程:0
10:19:58.170 [Thread-4] INFO com.xxxx - 我是异步线程:4
10:19:58.170 [Thread-1] INFO com.xxxx - 我是异步线程:1
10:19:58.170 [Thread-3] INFO com.xxxx - 我是异步线程:3

案例3：修改主线程休眠时间长一点，改成7s，代码如下：

    public static void main(String[] args) throws Exception{log.info("主线程开始");CountDownLatch latch = new CountDownLatch(5);for (int i = 0; i < 5; i++) {int finalI = i;new Thread(() -> {// 执行任务async(finalI);latch.countDown(); // 完成后计数器减1}).start();}//CountDownLatch 的 await(long timeout, TimeUnit unit) 方法用于等待计数器归零，但会设置最大等待时间。其返回值 boolean 表示计数器是否在超时前归零，具体含义如下：//true：计数器在超时时间内归零，说明所有任务已完成。//false：超时时间已过，但计数器仍未归零，说明部分任务未完成。boolean await = latch.await(7, TimeUnit.SECONDS);log.info("异步线程都执行完毕了:{}",await);}public static void async(Integer i){try {Thread.sleep(5000l);} catch (InterruptedException e) {throw new RuntimeException(e);}//System.out.println("我是异步线程"+i);log.info("我是异步线程:{}",i);}

打印结果如下：

10:26:29.930 [main] INFO com.xxxx- 主线程开始
10:26:34.981 [Thread-4] INFO com.xxxx - 我是异步线程:4
10:26:34.981 [Thread-3] INFO com.xxxx - 我是异步线程:3
10:26:34.981 [Thread-1] INFO com.xxxx - 我是异步线程:1
10:26:34.981 [Thread-2] INFO com.xxxx - 我是异步线程:2
10:26:34.981 [Thread-0] INFO com.xxxx - 我是异步线程:0
10:26:34.989 [main] INFO com.xxxx - 异步线程都执行完毕了:true

案例4：若任务数量不确定（如根据业务动态生成），可先初始化 CountDownLatch，在提交任务时递增计数器

// 初始计数器为0
CountDownLatch latch = new CountDownLatch(0);
// 动态提交任务并增加计数器
for (int i = 0; i < dynamicTaskCount; i++) {// 先增加计数器latch = new CountDownLatch(latch.getCount() + 1);//executor是我设置的线程池executor.submit(() -> {try { //执行业务方法} finally {//程序最后一定要保证计数器减1latch.countDown(); }});
}
latch.await(); // 主线程等待，直到计数器为0
log.info("子线程已经执行完毕");

常见错误场景

1、计数器与任务数量不匹配：
若 CountDownLatch 的初始值小于任务数量，主线程可能提前结束等待；若大于任务数量，主线程会永久等待。
2、countDown () 位置错误：
若在任务执行前调用 countDown()，主线程可能在任务未完成时就被唤醒。
3、未处理异常：
若任务抛出异常且未在 finally 块中调用 countDown()，计数器不会递减，导致主线程永久等待。

Semaphore：
信号量：控制同时访问某个资源的线程数量（类似 “许可证” 机制）
示例：限制最多 2 个线程同时执行任务

    public static void main(String[] args) throws Exception{Semaphore semaphore = new Semaphore(2);for (int i = 0; i < 5; i++) {int finalI = i;new Thread(() -> {try {semaphore.acquire(); // 获取许可证（若满则等待）// 执行任务async(finalI);}catch (Exception e){log.error("执行代码异常",e);}finally {semaphore.release(); // 释放许可证}}).start();}}public static void async(Integer i){try {Thread.sleep(5000l);} catch (InterruptedException e) {throw new RuntimeException(e);}//System.out.println("我是异步线程"+i);log.info("我是异步线程:{}",i);}

打印结果如下：可以从打印的时间（34s，39s，44s）来看，每次最多只有两个线程执行

11:01:34.423 [Thread-1] INFO com.xxxx - 我是异步线程:1
11:01:34.423 [Thread-0] INFO com.xxxx - 我是异步线程:0
11:01:39.542 [Thread-2] INFO com.xxxx - 我是异步线程:2
11:01:39.542 [Thread-3] INFO com.xxxx - 我是异步线程:3
11:01:44.554 [Thread-4] INFO com.xxxx - 我是异步线程:4