CountDownLatch、CyclicBarrier、Semaphore的使用

一、CountDownLatch

CountDownLatch（倒计时计数器、闭锁），让一些线程阻塞直到另一些线程完成一些操作才被唤醒

CountDownLatch主要有两个方法：当一个或多个线程调用await()方法时，调用线程会被阻塞；其他线程调用countDown()方法会将计数器减一，调用countDown()方法不会被阻塞

当计数器的值为0时，调用await()方法被阻塞的线程会被唤醒

public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for(int i = 0; i < 5; i++){
            new Thread(()->{
                try {
                    TimeUnit.SECONDS.sleep(1);//睡眠1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "t 线程");
                countDownLatch.countDown(); //计数器减一
            }, String.valueOf(i)).start();
        }

        countDownLatch.await();//计数器为0时，唤醒线程
        System.out.println(Thread.currentThread().getName() + "t 线程");
    }
}

结果：

4 线程
1 线程
2 线程
0 线程
3 线程
main 线程

二、CyclicBarrier

CyclicBarrier（可循环屏障，栅栏），让一组线程到达一个屏障（同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，线程才会继续执行

public class CyclicBarrierTest {
    public static void main(String[] args) {
//        CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3, ()->{
            System.out.println(Thread.currentThread().getName() + "t work");
        });
        for(int i = 0; i < 6; i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "t begin");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "t end");
            }, String.valueOf(i)).start();
        }
    }
}

结果：

0 begin
1 begin
2 begin
2 work
3 begin
2 end
1 end
0 end
4 begin
5 begin
5 work
5 end
3 end
4 end

三、Semaphore

Semaphore（信号量），主要用于两个目的，一个是用于多个共享资源的互斥作用，另一个用于并发线程数的控制

public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);//模拟3个停车位
        for(int i = 0; i < 6; i++){//模拟6部汽车
            new Thread(()->{
                try {
                    semaphore.acquire();
                    int time = (int)(1+Math.random()*(10-1+1));
                    System.out.println(Thread.currentThread().getName() + "t抢到车位, 使用"+time+"秒");
                    TimeUnit.SECONDS.sleep(time);
                    System.out.println(Thread.currentThread().getName() + "t离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }
            }, String.valueOf(i)).start();
        }
    }
}

结果：

2 抢到车位, 使用6秒
0 抢到车位, 使用10秒
1 抢到车位, 使用9秒
2 离开车位
4 抢到车位, 使用3秒
4 离开车位
1 离开车位
3 抢到车位, 使用5秒
5 抢到车位, 使用4秒
0 离开车位
5 离开车位
3 离开车位

四、总结

场景:

1. CountDownLatch 场景 ：多线程并行执行，等待所有线程全部完成再汇总结果
   经典：多线程批量查询数据库、多文件并行读取、接口并发调用，等所有任务结束后统一整理数据。
   例：开启 10 个线程分别查询 10 张表，主线程等全部查询完毕，汇总组装返回数据。

2. CyclicBarrier 场景：多阶段并行计算（分段任务，阶段同步）
   大数据分片计算：
   第一轮：10 个线程分片计算原始数据；
   全部计算完成后，统一汇总第一轮结果；
   第二轮再基于汇总结果二次分片计算。
   每一轮用 CyclicBarrier 做阶段卡点，一轮结束自动开启下一轮。

3. Semaphore 场景：接口 / 服务限流（最常用）
   高并发接口限制最大并发访问量，例如接口最大同时 100 个请求，超过则排队阻塞，防止服务打垮。

三者核心对比

总结:

1. 只想等一批线程干完活再往下走 → CountDownLatch
2. 多线程要分批、一轮一轮同步卡点 → CyclicBarrier
3. 限制同时最多多少线程运行、限流控资源 → Semaphore