Java并发编程（CyclicBarrier）实例详解

概述

Java并发编程的一个重要组成部分就是同步化，也就是为了解决多线程情况下线程之间的通信和数据共享的问题。在实际开发中，有些业务场景需要多个线程一起协作完成某个任务，这个时候就需要用到CyclicBarrier。

CyclicBarrier是一个同步工具类，当线程执行到CyclicBarrier的时候，会等待其他线程到达，直到所有线程都到达后才会继续执行。CyclicBarrier提供了一个非常有用的构造函数，在构造函数中可以定义一个屏障操作，屏障操作会在所有线程到达前执行。

CyclicBarrier的使用

使用CyclicBarrier需要以下几个步骤：

1. 创建一个CyclicBarrier对象

java
CyclicBarrier cyclicBarrier = new CyclicBarrier(int parties, Runnable barrierAction);

参数parties表示需要等待到达屏障的线程的个数，barrierAction是屏障操作，当所有线程到达屏障前执行。

1. 每个线程执行到CyclicBarrier的时候，调用await()方法等待。

java
cyclicBarrier.await();

当线程到达屏障后，如果所有线程都已经到达，就会执行barrierAction。然后所有线程继续执行。

下面将用两个示例说明CyclicBarrier的使用。

示例1：多个线程协作完成一个任务

需求：实现多个人一起协作开会的场景，人到齐了才能开始开会。

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

public class Meeting {
    public static void main(String[] args) {
        int personCount = 6;
        Runnable barrierAction = () -> System.out.println("所有人到齐了，开始开会。");
        CyclicBarrier cyclicBarrier = new CyclicBarrier(personCount, barrierAction);

        for (int i = 0; i < personCount; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + " 来了。");
                    cyclicBarrier.await();
                    System.out.println(Thread.currentThread().getName() + " 开始开会。");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, "person " + i).start();
        }
    }
}

示例输出：

person 0 来了。
person 2 来了。
person 1 来了。
person 4 来了。
person 3 来了。
person 5 来了。
所有人到齐了，开始开会。
person 0 开始开会。
person 1 开始开会。
person 3 开始开会。
person 2 开始开会。
person 4 开始开会。
person 5 开始开会。

示例2：多个线程同时请求一个接口

需求：多个线程同时请求一个接口，当所有线程都请求完毕后，再进行下一步操作。

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

public class HttpRequest {
    public static void main(String[] args) {
        int threadCount = 5;
        Runnable barrierAction = () -> System.out.println("所有请求都已经完成，开始下一步操作。");
        CyclicBarrier cyclicBarrier = new CyclicBarrier(threadCount, barrierAction);

        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " 发送请求。");
                try {
                    Thread.sleep((long) (Math.random() * 5000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 请求完成。");

                try {
                    cyclicBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, "thread " + i).start();
        }
    }
}

示例输出：

thread 0 发送请求。
thread 3 发送请求。
thread 2 发送请求。
thread 1 发送请求。
thread 4 发送请求。
thread 1 请求完成。
thread 3 请求完成。
thread 0 请求完成。
thread 4 请求完成。
thread 2 请求完成。
所有请求都已经完成，开始下一步操作。