本文共 5803 字，大约阅读时间需要 19 分钟。

CyclicBarrier称为循环屏障

它允许一组线程互相等待，直到达到某个公共的屏障点

CyclicBarrier和CountDownLatch有一些相似。CountDownLatch表示只有线程执行结束后当前线程才可以继续执行和Join方法一致。但是CyclicBarrier是只有等待的线程数达到一定的值时才继续执行。该值在我们创建对象的时候传递

public CyclicBarrier(int parties);在给定数量的线程数未达到时进行等待

自定义一个屏障操作，在线程数达到屏障点时主动调用屏障操作的run方法

CyclicBarrier(int parties, Runnable barrierAction)       创建一个新的 CyclicBarrier，并自定义一个屏障操作。

案例1：

import java.util.concurrent.CyclicBarrier;public class CyclicBarrierTest {
       public static void main(String[] args) {
           CyclicBarrier cyclicBarrier = new CyclicBarrier(10, new Runnable() {
               @Override            public void run() {
                   //该方法在线程数达到屏障点时立即触发                System.out.println("车已坐满,准备发车");            }        });        System.out.println("观光车可以上车啦");        for (int i = 1; i <= 10; i++) {
               try {
                   Thread.sleep(1000);//模拟上车的过程            } catch (InterruptedException e) {
                   e.printStackTrace();            }            new Car("游客"+i,cyclicBarrier).start();        }    }}class Car extends Thread{
       CyclicBarrier cyclicBarrier;    public Car(String name,CyclicBarrier cyclicBarrier){
           super(name);        this.cyclicBarrier = cyclicBarrier;    }    @Override    public void run() {
           try{
             System.out.println(Thread.currentThread().getName()+"上车");          long start = System.currentTimeMillis();          //此时线程来时阻塞，直到线程数量达到屏障点          cyclicBarrier.await();          long end = System.currentTimeMillis();          System.out.println(Thread.currentThread().getName()+"在观光车上等待了"+(end-start)+"ms");        }catch (Exception e){
               e.printStackTrace();        }    }}

结果分析：

CyclicBarrier内部相当于有个计数器（构造方法传入的），每次调用await();后，计数器会减1，并且await()方法会让当前线程阻塞，等待计数器减为0的时候，所有在await()上等待的线程被唤醒，然后继续向下执行，此时计数器又会被还原为创建时的值，然后可以继续再次使用,这就是循环！。

案例2，模拟吃饭等10个人到齐了就开始吃饭

import java.util.concurrent.CyclicBarrier;public class CyclicBarrierTest {
       public static void main(String[] args) {
           CyclicBarrier cyclicBarrier = new CyclicBarrier(10, new Runnable() {
               @Override            public void run() {
                   System.out.println("人到齐了开始吃饭吧");            }        });        for (int i = 1; i <= 10; i++) {
               try {
                   Thread.sleep(1000);                //休眠模拟吃货的到来            } catch (InterruptedException e) {
                   e.printStackTrace();            }            new Eat("吃货"+i,cyclicBarrier).start();        }    }}class Eat extends Thread{
       CyclicBarrier cyclicBarrier;    public Eat(String name,CyclicBarrier cyclicBarrier){
           super(name);        this.cyclicBarrier = cyclicBarrier;    }    @Override    public void run() {
           try{
               System.out.println(Thread.currentThread().getName()+"来了，等待别人");            long start = System.currentTimeMillis();            //会将计数器减一            cyclicBarrier.await();            long end = System.currentTimeMillis();            System.out.println(Thread.currentThread().getName()+"等待了"+(end-start)+"ms,开始吃饭");        }catch (Exception e){
               e.printStackTrace();        }    }}

import java.util.concurrent.CyclicBarrier;public class CyclicBarrierTest {
       public static void main(String[] args) throws InterruptedException {
           CyclicBarrier cyclicBarrier = new CyclicBarrier(10, new Runnable() {
               @Override            public void run() {
                   System.out.println("人到齐了开始吃饭吧");            }        });        for (int i = 1; i <= 10; i++) {
               try {
                   Thread.sleep(1000);            } catch (InterruptedException e) {
                   e.printStackTrace();            }            Eat eat =  new Eat("吃货"+i,cyclicBarrier);            eat.start();            if(i == 5){
                   Thread.sleep(100);                eat.interrupt();            }        }    }}class Eat extends Thread{
       CyclicBarrier cyclicBarrier;    public Eat(String name,CyclicBarrier cyclicBarrier){
           super(name);        this.cyclicBarrier = cyclicBarrier;    }    @Override    public void run() {
           long start = 0;        try{
               System.out.println(Thread.currentThread().getName()+"来了，等待别人");            start = System.currentTimeMillis();            cyclicBarrier.await();        }catch (Exception e){
               e.printStackTrace();        }        long end = System.currentTimeMillis();        System.out.println(Thread.currentThread().getName()+"等待了"+(end-start)+"ms,开始吃饭");    }}class Car extends Thread{
       CyclicBarrier cyclicBarrier;    public Car(String name,CyclicBarrier cyclicBarrier){
           super(name);        this.cyclicBarrier = cyclicBarrier;    }    @Override    public void run() {
           try{
             System.out.println(Thread.currentThread().getName()+"上车");          long start = System.currentTimeMillis();          cyclicBarrier.await();          long end = System.currentTimeMillis();          System.out.println(Thread.currentThread().getName()+"在观光车上等待了"+(end-start)+"ms");        }catch (Exception e){
               e.printStackTrace();        }    }}

结果查看：

吃货5到来之前所有先到的吃货都在等待，而吃货5来了之后因为特殊情况就先吃了。此时等待的吃货看到这种情况后便不在等待了，也直接开吃了。后来的吃货来了之后看到这种情况便不等待了直接开吃。

在线程调用interrupt()方法时，此时的阻塞线程会抛出异常BrokenBarrierException异常，而后边的代码会继续执行

小结：

设置等待时间

cyclicBarrier.await(1, TimeUnit.SECONDS);该线程只会等待1秒钟，若是阻塞情况的话将抛出InterruptException异常

如果超时引发异常后，便会打破规则！和上述情况一致

规则的恢复

reset();//规则的重置

最后大家可以比较一下CyclicBarrier和CountDownLatch的区别

转载地址：http://rjxzi.baihongyu.com/