CountDownLatch与CyclicBarrier对比解析

CountDownLatch和CyclicBarrier均为Java并发工具类，区别在于前者为一次性倒计时器，后者可循环使用。1. CountDownLatch通过countDown()递减计数，计数为0后唤醒await()线程，适用于一个或多个线程等待其他线程完成任务的场景；2. CyclicBarrier通过await()使一组线程互相等待至屏障点后同时释放，并可重复使用，适合多个线程同步执行某阶段任务后再继续后续操作。两者在计数方式、可重用性、用途及线程数量要求上均有差异，选择时应根据具体需求判断。

CountDownLatch和CyclicBarrier都是Java并发包java.util.concurrent中的同步工具类，用于协调多个线程的执行。关键区别在于CountDownLatch是一次性的倒计时器，而CyclicBarrier则可以循环使用。CountDownLatch主要用于一个或多个线程等待其他线程完成操作，而CyclicBarrier用于一组线程互相等待至到达某个公共屏障点，然后同时继续执行。

CountDownLatch vs. CyclicBarrier：用法详解与场景分析

CountDownLatch的用法

CountDownLatch基于计数器实现。初始化时设置一个计数器的值，调用countDown()方法会将计数器减1，直到计数器变为0，调用await()方法的线程会被唤醒。

• 初始化： CountDownLatch latch = new CountDownLatch(n); // n为计数器初始值
• 递减计数器： latch.countDown(); // 通常在执行任务的线程中调用
• 等待： latch.await(); // 调用此方法的线程会阻塞，直到计数器变为0

示例：模拟运动员等待发令枪响

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {

    public static void main(String[] args) throws InterruptedException {
        int numberOfRunners = 5;
        CountDownLatch startSignal = new CountDownLatch(1); // 发令枪
        CountDownLatch doneSignal = new CountDownLatch(numberOfRunners); // 所有运动员完成的信号

        for (int i = 0; i < numberOfRunners; ++i) {
            new Thread(new Runner(startSignal, doneSignal, i)).start();
        }

        System.out.println("准备...");
        Thread.sleep(1000); // 模拟准备时间
        System.out.println("发令枪响！");
        startSignal.countDown(); // 发令枪响
        doneSignal.await(); // 等待所有运动员完成
        System.out.println("比赛结束！");
    }
}

class Runner implements Runnable {
    private final CountDownLatch startSignal;
    private final CountDownLatch doneSignal;
    private final int id;

    Runner(CountDownLatch startSignal, CountDownLatch doneSignal, int id) {
        this.startSignal = startSignal;
        this.doneSignal = doneSignal;
        this.id = id;
    }

    public void run() {
        try {
            startSignal.await(); // 等待发令枪响
            System.out.println("运动员 " + id + " 开始跑...");
            Thread.sleep((long)(Math.random() * 1000)); // 模拟跑步时间
            System.out.println("运动员 " + id + " 到达终点！");
            doneSignal.countDown(); // 完成
        } catch (InterruptedException ex) {
            // ...
        }
    }
}

CyclicBarrier的用法

CyclicBarrier允许一组线程互相等待，直到所有线程都到达一个公共屏障点。到达屏障后，所有线程会被同时释放，继续执行。CyclicBarrier可以重用，每次所有线程到达屏障后，屏障会被重置，可以进行下一轮的等待。

• 初始化： CyclicBarrier barrier = new CyclicBarrier(n); // n为线程数量
• 等待： barrier.await(); // 调用此方法的线程会阻塞，直到所有线程都到达屏障

示例：模拟多个线程计算部分结果，然后汇总

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {

    public static void main(String[] args) {
        int numberOfThreads = 3;
        CyclicBarrier barrier = new CyclicBarrier(numberOfThreads, () -> {
            System.out.println("所有线程到达屏障，汇总结果...");
        });

        for (int i = 0; i < numberOfThreads; i++) {
            new Thread(new Worker(barrier, i)).start();
        }
    }
}

class Worker implements Runnable {
    private final CyclicBarrier barrier;
    private final int id;

    Worker(CyclicBarrier barrier, int id) {
        this.barrier = barrier;
        this.id = id;
    }

    public void run() {
        try {
            System.out.println("线程 " + id + " 开始计算...");
            Thread.sleep((long)(Math.random() * 1000)); // 模拟计算时间
            System.out.println("线程 " + id + " 完成计算，等待其他线程...");
            barrier.await(); // 等待其他线程
            System.out.println("线程 " + id + " 继续执行...");
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

CountDownLatch和CyclicBarrier的异同点总结

• 计数方式： CountDownLatch是递减计数，CyclicBarrier是递增计数（直到达到parties数量）。
• 可重用性： CountDownLatch是一次性的，计数器变为0后就不能再使用了。CyclicBarrier可以重用，每次所有线程到达屏障后，屏障会被重置。
• 用途： CountDownLatch通常用于一个或多个线程等待其他线程完成任务。CyclicBarrier通常用于一组线程互相等待，然后同时开始下一轮任务。
• 线程数量： CountDownLatch中，参与countDown()的线程数量不一定等于初始化的计数值。CyclicBarrier中，参与await()的线程数量必须等于初始化时的parties数量。
• 执行动作： CyclicBarrier可以在所有线程到达屏障后执行一个Runnable任务。CountDownLatch没有这个功能。

如何选择CountDownLatch还是CyclicBarrier？

选择哪个取决于具体的场景。如果只需要一个线程等待其他线程完成任务，CountDownLatch更合适。如果需要一组线程互相等待，然后同时开始下一轮任务，CyclicBarrier更合适。

CountDownLatch的常见应用场景

• 主线程等待多个子线程完成初始化工作。 例如，应用程序启动时，主线程等待多个模块初始化完成后再继续执行。
• 测试框架中，等待所有测试用例执行完成。

CyclicBarrier的常见应用场景

• 并行计算： 将一个大任务分解成多个子任务，每个线程负责计算一部分，所有线程计算完成后，汇总结果。
• 游戏开发： 多个玩家等待所有玩家都准备好后，游戏开始。
• 机器学习： 多个worker节点并行训练模型，每个worker节点训练一部分数据，所有worker节点训练完成后，同步模型参数。

CountDownLatch的性能考量

CountDownLatch的性能瓶颈主要在于竞争。当多个线程同时调用countDown()方法时，可能会出现竞争，导致性能下降。可以使用AtomicInteger来优化计数器的递减操作，减少竞争。

CyclicBarrier的异常处理

CyclicBarrier可能会抛出InterruptedException和BrokenBarrierException异常。InterruptedException表示线程在等待过程中被中断。BrokenBarrierException表示屏障被破坏，通常是因为一个或多个线程在等待过程中抛出了异常。

CountDownLatch与FutureTask结合使用

CountDownLatch可以和FutureTask结合使用，实现更复杂的并发控制。例如，可以使用FutureTask异步执行任务，然后使用CountDownLatch等待所有任务完成。

CyclicBarrier与ExecutorService结合使用

CyclicBarrier可以和ExecutorService结合使用，方便地管理线程池中的线程。例如，可以使用ExecutorService创建线程池，然后使用CyclicBarrier等待所有线程完成任务。

CountDownLatch的局限性

CountDownLatch是一次性的，不能重用。如果需要重用，可以使用ReentrantLock和Condition来实现类似的功能。

CyclicBarrier的替代方案

在某些情况下，可以使用Phaser来替代CyclicBarrier。Phaser比CyclicBarrier更灵活，可以动态地调整参与同步的线程数量。