CyclicBarrier的使用

CyclicBarrier称为循环屏障

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

CyclicBarrier和CountDownLatch有一些相似。CountDownLatch表示只有线程执行结束后当前线程才可以继续执行和Join方法一致。但是CyclicBarrier是只有等待的线程数达到一定的值时才继续执行。该值在我们创建对象的时候传递
CyclicBarrier的计数器可以重置，因此他的实例可以反复使用

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

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

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

案例1：
游客需要坐观光车进行游览，只有坐满(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("车已坐满,准备发车");
            }
        });
        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异常，而后边的代码会继续执行

小结：
1.一旦有一个线程接收到中断提醒便会打破现有的规则，无论阻塞中的线程或未阻塞的线程都会不在遵守现有的规则
2.接收到中断信号的线程时await()方法抛出InterruptException异常
3.未接收到中断信号的线程会在调用await()时抛出BrokenBarrierException

设置等待时间

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

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

规则的恢复
上述情况都破坏了我们原本定义的规则，这并不是我们乐意看到的，因此我们需要重置规则

reset();//规则的重置

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