Java多线程场景下 CountDownLatch、CyclicBarrier

在 Java 多线程编程的领域中，CountDownLatch、Semaphore 和 CyclicBarrier 是极为重要的同步工具，它们各自具备独特的功能与应用场景，熟练掌握这些工具，能极大地提升多线程程序的效率与稳定性。接下来，让我们深入探究这三个工具的奥秘。

CountDownLatch：线程的精准等待器

CountDownLatch 作为一个同步工具类，为线程间的协作提供了一种高效的等待机制。它允许一个或多个线程暂停执行，直至其他线程完成特定操作。其核心在于一个可递减的计数器，初始值通常设定为需要等待的线程数量。

工作原理与操作

每个线程完成自身任务后，调用 countDown() 方法，计数器随之减 1。当计数器递减至 0，意味着所有相关线程已完成任务，那些在 CountDownLatch 上等待的线程便得以继续执行。这就好比一场接力赛，所有接力选手都完成交接棒后，最后冲刺的选手才能全力冲向终点。

CyclicBarrier：线程协作的循环集结点

CyclicBarrier 是一个循环屏障工具类，为一组线程提供了一个同步点，使它们能够相互等待，直到所有线程都到达这个公共屏障点。一旦所有线程都到达，CyclicBarrier 便会释放所有线程，让它们继续执行后续任务。每个线程在执行到特定位置时，调用 await() 方法等待其他线程。当最后一个线程到达屏障点时，所有等待的线程被释放，继续执行后续操作。

以运动场比赛场景为例：代码实现与解析

为了更直观地理解 CountDownLatch 和 CyclicBarrier 在实际场景中的应用，我们以运动场比赛为例，通过代码来一探究竟。

运动场上面，一排运动员站在起跑线上，只听见裁判员，一声哨响，大家汗流浃背的跑起来，一个一个的运动员到达终点线后，比赛结束。上代码，针对这个场景，先来看一下代码

运动员类（Sportsman）

import java.util.Random;
//运动员
public class Sportsman {
    private String name;
    private String id;

    public Sportsman(String name, String id) {
        this.name = name;
        this.id = id;
    }

    public void ready() {
        System.out.println(name + ": " + id + " is readying");
    }

    public void run() {
        System.out.println(name + ": " + id + " is running");
    }

    public void end() throws InterruptedException {
        //运动跑步时间
        Thread.sleep(new Random().nextInt(10)*1000);
        System.out.println(name + ": " + id + " is end");
    }
}

在这个 Sportsman 类中，我们定义了运动员的基本信息（姓名 name 和编号 id）以及他们在比赛过程中的三个关键行为：准备（ready）、奔跑（run）和结束比赛（end）。其中，end 方法中通过 Thread.sleep 模拟了运动员跑步所需的时间，增加了场景的真实性。

主演示类（JucDemo）

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;

public class JucDemo {
    private static List<Sportsman> sportsmanList = new ArrayList<>();
    public static void main(String[] args) throws InterruptedException {
        //参加运动员
        for (int i = 0; i < 4; i++) {
            Sportsman sportsman = new Sportsman("运动员" + i, "10001" + i);
            JucDemo.sportsmanList.add(sportsman);
        }

        CyclicBarrierDemo.begin();
        CountDownLatchDemo.end();
    }

    public static class CyclicBarrierDemo {
        /**
         * 用于同步6个运动员线程的屏障，当所有运动员到达后会触发裁判员的指令打印
         */
        private static CyclicBarrier barrier = new CyclicBarrier(4, () ->
                System.out.println("所有运动员入场，准备好了，大家一起出发！"));

        public static void begin() {
            for (Sportsman sportsman : sportsmanList) {
                new Thread(() -> {
                    try {
                        sportsman.ready();
                        // 等待所有运动员到场,裁判吹哨
                        barrier.await();
                        sportsman.run();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }).start();
            }
        }
    }

    public static class CountDownLatchDemo{
        private static CountDownLatch stop = new CountDownLatch(sportsmanList.size());
        public static void end() throws InterruptedException{
            for(Sportsman sportsman : sportsmanList){
                new Thread(() -> {
                    try {
                        //运动结束比赛
                        sportsman.end();
                        stop.countDown();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }).start();
            }
            //等待所有运动员跑完
            stop.await();
            System.out.println("所有运动员都跑完，比赛结束！");
        }
    }
}

在 JucDemo 类中，我们首先创建了一个 sportsmanList 列表，用于存储所有参赛运动员。在 main 方法里，初始化了 4 位运动员并添加到列表中。

CyclicBarrierDemo 内部类负责模拟运动员准备和起跑的过程。通过创建一个 CyclicBarrier 对象，我们设定当 4 个运动员（线程）都调用 await() 方法到达屏障点时，会执行传入的 Runnable 任务，即打印 “所有运动员入场，准备好了，大家一起出发！”。每个运动员线程在准备完毕后，调用 barrier.await() 等待其他运动员，当所有人都准备好，一起起跑。

CountDownLatchDemo 内部类则专注于统计运动员完成比赛的情况。通过创建一个 CountDownLatch 对象，初始值为运动员的数量。每个运动员线程在完成比赛（调用 sportsman.end()）后，调用 stop.countDown() 使计数器减 1。主线程通过调用 stop.await() 等待计数器归零，即所有运动员都完成比赛，然后打印 “所有运动员都跑完，比赛结束！”。

运行结果解析

运行上述代码，我们得到如下结果：

运动员0: 100010 is readying
运动员1: 100011 is readying
运动员2: 100012 is readying
运动员3: 100013 is readying
所有运动员入场，准备好了，大家一起出发！
运动员3: 100013 is running
运动员0: 100010 is running
运动员1: 100011 is running
运动员2: 100012 is running
运动员0: 100010 is end
运动员3: 100013 is end
运动员1: 100011 is end
运动员2: 100012 is end
所有运动员都跑完，比赛结束！

从结果中可以清晰地看到，运动员们先各自准备，当所有运动员准备好后，CyclicBarrier 触发裁判员指令，运动员们一起起跑。随后，运动员们陆续完成比赛，当所有运动员都结束比赛后，CountDownLatch 发出信号，宣布比赛结束。这生动地展示了 CountDownLatch 和 CyclicBarrier 在多线程协作场景中的协同工作过程。

通过这个实例，相信大家对 CountDownLatch 和 CyclicBarrier 的工作原理和应用场景有了更深刻的理解。在实际的多线程编程中，合理运用这两个工具，能够巧妙地解决各种复杂的线程同步问题，使程序的运行更加高效、稳定。