[Java并发编程实战] 栅栏 CyclicBarrier 实现（含代码）

温故而知新，可以为师矣。—《论语》
它的意思是：“温习旧知识从而得知新的理解与体会，凭借这一点就可以成为老师了

PS: 如果觉得本文有用的话，请帮忙点赞，留言评论支持一下哦，您的支持是我最大的动力！谢谢啦~

栅栏(Barrier)类似于闭锁，他能阻塞一组线程直到某个事件发生后再全部同时执行。CyclicBarrier 字面意思是回环栅栏，回环的意思是它能够被重复利用，当然前提是在所有线程释放了以后。

CyclicBarrier 和 CountDownLatch 的主要区别：

• CyclicBarrier 是所有线程必须同时到达栅栏位置，才能继续执行。它用于等待其他线程，并且能够重置使用。
• CountDownLatch 用于等待事件，是一次性对象，一旦进入终止状态，就不能被重置。
• CountDownLatch 通常阻塞的是主线程，开锁以后主线程才继续执行。
• CyclicBarrier 阻塞的是子线程，到达栅栏位置后，每个线程还可以继续做自己后续的事情。

CyclicBarrier 的核心方法

首先，看它的构造函数，有两个构造函数。

    //构造函数一
    public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
    }
    //构造函数二
    public CyclicBarrier(int parties) {
        this(parties, null);
    }

参数 parties 表示参与的线程或者任务有多少个。 参数 barrierAction 是在 parties 个线程都到达 barrier 状态后，才会去执行，它是在一个已有的子任务线程中执行。

其次，它的主要方法是 await()，同样也有两个版本：

public int await() throws InterruptedException, BrokenBarrierException {
    try {
        return dowait(false, 0L);
    } catch (TimeoutException toe) {
        throw new Error(toe); // cannot happen
    }
}

public int await(long timeout, TimeUnit unit)
    throws InterruptedException,
           BrokenBarrierException,
           TimeoutException {
    return dowait(true, unit.toNanos(timeout));
}

第一个方法比较常用，它用来阻塞当前线程，直至所有的线程到达 barrier 状态才继续执行。
第二个方法顾名思义，如果有某个线程超时还没到达 barrier 状态，将会抛出 BrokenBarrierException
异常，并且其他已经到达的线程继续执行后续任务。

应用场景

所有的子任务（子线程）需要在到达某个状态前挂起，直到所有的子任务（子线程）都到达栅栏状态时，它们才能继续执行下一步操作，这个时候就可以选择使用CyclicBarrier。

来看一个简单的例子：

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

public class CyclicBarrierTest{
    
    private static final int SIZE = 5; //创建子线程的数量
    
    public static void main(String[] args) {
        //创建关卡对象
        CyclicBarrier cb = new CyclicBarrier(SIZE, new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + ":" + " all sub thead end");//所有子线程执行完毕时执行
            }});
        //创建并启动五个子线程
        for(int i = 0; i < SIZE; i++) {
            new Thread(new SubThread(cb)).start();
        }
    }

    static class SubThread implements Runnable{

        private CyclicBarrier cb; //栅栏对象
        
        public SubThread(CyclicBarrier cb) {
            this.cb = cb;
        }

        @Override
        public void run() {
            //当前线程开始运行
            System.out.println(Thread.currentThread().getName() + ": sub thread starting running");
            try {
                cb.await();//计数器加1，等待其他线程执行到同样的地方
                //子线程全部继续执行
                System.out.println(Thread.currentThread().getName() + ":" +" all sub thread start doing other things");
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

运行结果是：

这里写图片描述

看打印的 log，可以清楚的显示他们的工作流程了。首先五个线程开始执行直接进入阻塞状态，接着，所有线程到达栅栏状态；然后任意一个线程去运行 CyclicBarrier 的 runnable 参数。这个时候，所有子线程并没有释放，运行完 runnable，五个线程将会继续执行，处理各自的事物。

没有什么比自己写代码来验证更清晰的了。

本文完结，如对你有帮助，欢迎关注我，谢谢啦