Java面试题：解释CountDownLatch, CyclicBarrier和Semaphore在并发编程中的使用

在并发编程中，CountDownLatch、CyclicBarrier 和 Semaphore 是 Java 提供的同步辅助类，它们用于控制线程之间的协调。以下是每个类的基本用法和特点：

CountDownLatch（倒计时门闩）：

CountDownLatch 是一个同步辅助器，允许一个或多个线程等待一组其他线程完成操作。
它通过一个计数器来工作，初始化时设定一个计数值，每当一个线程完成它的任务，计数器的值就会减一。
当计数器的值到达零时，所有等待在这个 CountDownLatch 上的线程都会继续执行。
一个典型用例是，当主线程需要等待多个工作线程完成它们的任务后才能继续执行。

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        int workerCount = 5;
        CountDownLatch latch = new CountDownLatch(workerCount);

        for (int i = 0; i < workerCount; i++) {
            new Thread(() -> {
                // 模拟工作线程执行任务
                System.out.println(Thread.currentThread().getName() + " finished work.");
                latch.countDown();
            }).start();
        }

        latch.await(); // 主线程等待，直到所有工作线程完成任务
        System.out.println("All workers have finished.");
    }
}

CyclicBarrier（循环屏障）：

CyclicBarrier 也用于线程之间的协调，但它可以重用。当一定数量的线程达到屏障时，这些线程会被阻塞，直到所有线程都到达屏障，然后所有线程才会继续执行。
CyclicBarrier 可以用于多轮的同步操作，当一轮操作完成后，屏障可以被重置，用于下一轮操作。
一个典型用例是，当一组线程需要相互等待，直到它们都到达某个点，然后一起继续执行下一个任务。

public class CyclicBarrierExample {
    public static void main(String[] args) throws InterruptedException {
        int workerCount = 5;
        CyclicBarrier barrier = new CyclicBarrier(workerCount, () -> System.out.println("All workers are ready to proceed to the next phase."));

        for (int i = 0; i < workerCount; i++) {
            new Thread(() -> {
                // 模拟工作线程执行任务
                System.out.println(Thread.currentThread().getName() + " is ready.");
                try {
                    barrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore（信号量）：

Semaphore 是一个计数信号量，用于控制同时访问某个特定资源的线程数量。
它通过一个许可计数来工作，线程可以通过调用 acquire() 方法来获取一个许可，当许可计数大于零时，acquire() 方法会减少许可计数并立即返回；如果许可计数为零，则调用线程会被阻塞，直到有其他线程调用 release() 方法增加许可计数。
Semaphore 可以用来实现流量控制，例如限制同时执行的线程数量，或者用于线程池中控制线程的并发数。

public class SemaphoreExample {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(2);

        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    // 模拟一个需要许可才能执行的任务
                    System.out.println(Thread.currentThread().getName() + " acquired a permit.");
                    // 模拟任务执行时间
                    Thread.sleep(1000);
                    semaphore.release();
                    System.out.println(Thread.currentThread().getName() + " released a permit.");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}