[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**。

来看一个简单的例子：

```java
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();
			}
		}
	}
}