CountDownLatch、CyclicBarrier、Semaphore

一、CountDownLatch
CountDownLatch是一个计数器类，用来控制线程等待其他线程执行完毕再继续执行。这个类通常用于主线程等待多个子线程完成任务后再进行下一步操作。CountDownLatch的实现基于AQS（AbstractQueuedSynchronizer），使用了共享锁的方式。
CountDownLatch的使用思路比较简单，首先创建一个CountDownLatch对象，并把需要等待的线程数量传入CountDownLatch的构造方法。然后在每个子线程完成任务时通过countDown()方法来减少计数器的值。当计数器变为0时，await()方法会返回，主线程就可以继续执行下一步操作。
代码示例：

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        int threadCount = 5;
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount ; i++) {
            new Thread(() -> {
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 执行完毕");
                countDownLatch.countDown();
            }).start();
        }

        countDownLatch.await();
        System.out.println("所有线程执行完毕");
    }
}

以上代码中，我们创建了一个CountDownLatch对象，并传入需要等待的线程数量。然后通过for循环创建了5个子线程，每个子线程都会睡眠1秒钟，模拟执行任务。当每个子线程完成任务后，调用countDown()方法来减少计数器的值。最后在主线程中调用await()方法来等待所有子线程完成任务。
二、CyclicBarrier
CyclicBarrier也是一个很有用的同步工具类，它可以让一组线程到达某个屏障（也可以理解为关卡）时被阻塞，直到所有线程都到达该屏障时才能继续执行。CyclicBarrier和CountDownLatch的区别在于，CountDownLatch只能使用一次，而CyclicBarrier可以重复使用。

CyclicBarrier的实现也是基于AQS（AbstractQueuedSynchronizer），但是使用了独占锁的方式。CyclicBarrier的使用思路也比较简单，首先创建一个CyclicBarrier对象，并把需要等待的线程数量和到达该屏障时需要执行的动作（可选）传入CyclicBarrier的构造方法。当所有线程到达该屏障时，CyclicBarrier会自动调用之前设置的动作（如果有），然后所有线程就可以继续执行接下来的操作。
代码示例：

public class CyclicBarrierDemo {
    public static void main(String[] args) throws InterruptedException, BrokenBarrierException {
        int threadCount = 3;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(threadCount, () -> System.out.println("所有线程到达屏障"));

        for (int i = 0; i < threadCount ; i++) {
            new Thread(() -> {
                try {
                    Thread.sleep(1000L);
                    System.out.println(Thread.currentThread().getName() + " 到达屏障");
                    cyclicBarrier.await();
                    System.out.println(Thread.currentThread().getName() + " 继续执行");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

我们创建了一个CyclicBarrier对象，并传入需要等待的线程数量和到达屏障时需要执行的动作。然后通过for循环创建了3个子线程，每个子线程都会睡眠1秒钟，并在到达屏障时调用await()方法。当所有子线程都到达屏障时，CyclicBarrier会自动执行之前设置的动作（输出“所有线程到达屏障”），然后所有线程就可以继续执行接下来的操作。
三、Semaphore
Semaphore是另一种常见的同步工具类，它可以限制同时访问某个共享资源的线程数量。Semaphore的实现也是基于AQS（AbstractQueuedSynchronizer），使用了共享锁的方式。

Semaphore的使用思路比较简单，首先创建一个Semaphore对象，并把该共享资源的数量传入Semaphore的构造方法。然后在每个需要访问该共享资源的线程中调用acquire()方法来获取访问权限，在使用完共享资源后再调用release()方法来释放访问权限。
代码示例：

public class SemaphoreDemo {
    public static void main(String[] args) {
        int threadCount = 10;
        Semaphore semaphore = new Semaphore(2);

        for (int i = 0; i < threadCount ; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + " 获取访问权限");
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                    System.out.println(Thread.currentThread().getName() + " 释放访问权限");
                }
            }).start();
        }
    }
}

我们创建了一个Semaphore对象，并传入该共享资源的数量。然后通过for循环创建了10个子线程，每个子线程需要获取访问权限才能执行，如果访问权限已满则需要等待其他线程释放访问权限。当使用完共享资源后，子线程需要调用release()方法来释放访问权限。