java并发包下CountDownLatch、Semaphore用法-优快云博客

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(); // 主线程等待，直到计数器为0
        log.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 {
         //程序最后一定要保证计数器减1
         latch.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