CyclicBarrier

1.CyclicBarrier 概念

CyclicBarrier是一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点（你设置的等待线程数量）。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 栅栏。

2. CyclicBarrier 的常用方法

CyclicBarrier(int parties);//设置有几个线程相互等待
CyclicBarrier(int parties, Runnable barrierAction)设置有几个线程相互等待 当达到等待数量时优先执行 Runnable barrierAction
await() 让所有线程都在此处等待 一直等待 直到都到了
await(long timeout, TimeUnit unit)让所有线程都在此处等待 等待多久（timeout）单位（unit） 当等待时间过了所有的线程还没有到的话就会抛出异常
 getNumberWaiting() 返回当前在关卡等待的队伍数量。*这个方法主要用于调试和断言

3. 案例 开会

@Slf4j
public class CyclicBarrierExample3 {
    private static Runnable  runnable=new Runnable() {
        @Override
        public void run() {
            log.info("人到完了开会，领导讲话散会");
        }
    };
    private  static CyclicBarrier barrier=new CyclicBarrier(5,
         runnable   );

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i=0;i<5;i++)
        {
            final  int threadNum=i;
            Thread.sleep(1000);
            executorService.execute(()->{
                try {
                    race(threadNum);
                } catch (Exception e) {
                 log.error("exception",e);
                }
            });
        }
        executorService.shutdown();

    }
    private static  void race(int t) throws InterruptedException, BrokenBarrierException {
        Thread.sleep(1000);
      log.info("{} 号员工来了在会议室等着",t);
        try {
            barrier.await(); //当达到等待个数才执行
        } catch (Exception e) {
            e.printStackTrace();
        }
        log.info("{} 号员工走了",t);
    }
}

聚餐

@Slf4j
public class CyclicBarrierExample2 {
    private  static CyclicBarrier barrier=new CyclicBarrier(5);

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i=0;i<5;i++)
        {
            final  int threadNum=i;
            Thread.sleep(1000);
            executorService.execute(()->{
                try {
                    race(threadNum);
                } catch (Exception e) {
                 log.error("exception",e);
                }
            });
        }
        executorService.shutdown();

    }
    private static  void race(int t) throws InterruptedException, BrokenBarrierException {
        Thread.sleep(1000);
      log.info("{}  号吃货来了在会议室等着",t);
        try {
            barrier.await(200, TimeUnit.MILLISECONDS); //当达到等待个数才执行
            barrier.getNumberWaiting();
        } catch (Exception e) {
            log.info("{} 号吃货等了一会见没人来",t);
        }
        log.info("{}  号吃货走了",t);
    }
}