CountDownLatch、CyclicBarrier和Semaphore区别及底层原理

1、CountDownLatch

表示计数器，可以给CountDownLatch设置一个数字，一个线程调用CountDownLatch的await()将会阻塞，其他线程调用CountDownLatch的countDown()方法来对CountDownLatch中的数字减一，当数字被减成0后，所有的await线程将被唤醒。

对应的底层原理就是，调用await()方法的线程会利用AQS队列，一旦数字被减为0，则会将AQS中正在排队的线程依次唤醒。

CountDownLatch的不足：CountDownLatch是一次性的，计算器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当CountDownLatch使用完毕后，它不能再次被使用。

使用场景：CountDownLatch可以应用于主线程等待所有子线程结束后再继续执行的情况。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + "->" + i);
            }
            countDownLatch.countDown();
        }).start();
        new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + "->" + i);
            }
            countDownLatch.countDown();
        }).start();
        countDownLatch.await();
        System.out.println("两个子线程都执行完毕，继续执行主线程");
    }
}

2. CyclicBarrier

CyclicBarraer可以使一组线程等待,当线程数量够时,一起执行，利用await()阻塞,每次阻塞一个线程并且计数变量减一，当计数变量为0时,将之前阻塞的线程都一起唤醒，当阻塞的线程达到了规定的数量的时候就一起释放。

CountDownLatch是先执行前置的线程,再执行任务线程
CyclicBarraer是指定一定数量的线程在某一刻一起执行

使用场景：用在所有子线程之间互相等待多次的情形。

public class Main {
    static class TaskThread extends Thread {
        CyclicBarrier barrier;

        public TaskThread(CyclicBarrier barrier) {
            this.barrier = barrier;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
                System.out.println(getName() + "比赛准备");
                barrier.await();
                System.out.println(getName() + "到达终点");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        int threadNum = 5;
        CyclicBarrier barrier = new CyclicBarrier(threadNum, () -> System.out.println(Thread.currentThread().getName() + "最后一个也准备好了，比赛开始"));

        for (int i = 0; i < threadNum; i++) {
            new TaskThread(barrier).start();
        }
    }

}

3. Semaphore

表示信号量，可以设置许可的个数，表示同时允许最多多少个线程使用该信号量，可以控制同时访问的线程个数。通过acquire()来获取许可，如果没有许可可用则线程阻塞并通过AQS来排队，可以通过release()方法来释放许可，当某个线程释放了某个许可后会从AQS中正在排队的第一个线程开始依次唤醒，直到没有空闲许可.

使用场景：流量控制，特别公用资源有限的应用场景，比如数据库连接。

public class Main {
    // 小区楼下停车场同时容纳的车辆2
    private static Semaphore semaphore = new Semaphore(2);

    public static void main(String[] args) {
        // 模拟5辆车进入停车场
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + "来到停车场");
                    if (semaphore.availablePermits() == 0) {
                        System.out.println("车位不足，请耐心等待");
                    }
                    // 获取令牌尝试进入停车场
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "成功进入停车场");
                    // 模拟车辆在停车场停留的时间
                    Thread.sleep(new Random().nextInt(10000));
                    System.out.println(Thread.currentThread().getName() + "驶出停车场");
                    // 释放令牌，腾出停车场车位
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }, i + "号车").start();
        }
    }
}