CyclicBarrier 让所有线程等待命令在继续执行

CyclicBarrier 让所有线程等待命令在继续执行

字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了。

CyclicBarrier类位于java.util.concurrent包下，CyclicBarrier提供2个构造器：

public CyclicBarrier(int parties, Runnable barrierAction) {
}
 
public CyclicBarrier(int parties) {
}

参数parties指让多少个线程或者任务等待至barrier状态；参数barrierAction为当这些线程都达到barrier状态时会执行的内容。

然后CyclicBarrier中最重要的方法就是await方法，它有2个重载版本：

public int await() throws InterruptedException, BrokenBarrierException { };
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };

第一个版本比较常用，用来挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务；

第二个版本是让这些线程等待至一定的时间，如果还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务。

例子 :

@Test
    public void contextLoadss() throws Exception {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
        executor.execute(() -> {
            try {
                System.out.println("写执行耗时需要5秒");
                TimeUnit.SECONDS.sleep(5);
                cyclicBarrier.await();
                System.out.println("5秒所有线程都执行完毕后继续进行执行");
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        executor.execute(() -> {
            try {
                System.out.println("写执行耗时需要8秒");
                TimeUnit.SECONDS.sleep(8);
                cyclicBarrier.await();
                System.out.println("8秒所有线程都执行完毕后继续进行执行");
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        executor.execute(() -> {
            try {
                System.out.println("写执行耗时需要3秒");
                TimeUnit.SECONDS.sleep(3);
                cyclicBarrier.await();
                System.out.println("3秒所有线程都执行完毕后继续进行执行");
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        TimeUnit.SECONDS.sleep(15);
        System.out.println("全部完毕执行");
    }
// 结果:
写执行耗时需要3秒
写执行耗时需要8秒
写执行耗时需要5秒
8秒所有线程都执行完毕后继续进行执行
3秒所有线程都执行完毕后继续进行执行
5秒所有线程都执行完毕后继续进行执行
全部完毕执行

如果说想在所有线程写入操作完之后，进行额外的其他操作可以为CyclicBarrier提供Runnable参数

@Test
    public void contextLoadss() throws Exception {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3,()-> System.out.println("3个线程阻塞完毕后执行了"));
     ..........其他代码与上面一样
    }

// 结果:
写执行耗时需要3秒
写执行耗时需要8秒
写执行耗时需要5秒
3个线程阻塞完毕后执行了
8秒所有线程都执行完毕后继续进行执行
3秒所有线程都执行完毕后继续进行执行
5秒所有线程都执行完毕后继续进行执行
全部完毕执行

可重用:

@Test
    public void contextLoadss() throws Exception {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3, () -> System.out.println("3个线程阻塞完毕后继续执行了"));
        // 第一次执行3次
        for (int i = 0; i < 3; i++) {
            int j = i;
            executor.execute(() -> {
                try {
                    System.out.println("写执行耗时需要" + (j + 5 )+ "秒");
                    TimeUnit.SECONDS.sleep(j + 5);
                    cyclicBarrier.await();
                    System.out.println((j + 5 )+ "秒所有线程都执行完毕后继续进行执行");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
        System.out.println("第一次执行");
        // 第二次执行3次
        for (int i = 0; i < 3; i++) {
            int j = i;
            executor.execute(() -> {
                try {
                    System.out.println("写执行耗时需要" + (j + 5 ) + "秒");
                    TimeUnit.SECONDS.sleep(j + 5);
                    cyclicBarrier.await();
                    System.out.println((j + 5 ) + "秒所有线程都执行完毕后继续进行执行");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
        TimeUnit.SECONDS.sleep(20);
        System.out.println("全部完毕执行");
    }
// 结果:
第一次执行
写执行耗时需要7秒
写执行耗时需要5秒
写执行耗时需要6秒
写执行耗时需要7秒
写执行耗时需要5秒
写执行耗时需要6秒
3个线程阻塞完毕后继续执行了
6秒所有线程都执行完毕后继续进行执行
5秒所有线程都执行完毕后继续进行执行
5秒所有线程都执行完毕后继续进行执行
3个线程阻塞完毕后继续执行了
7秒所有线程都执行完毕后继续进行执行
6秒所有线程都执行完毕后继续进行执行
7秒所有线程都执行完毕后继续进行执行
全部完毕执行

从执行结果可以看出，在初次的4个线程越过barrier状态后，又可以用来进行新一轮的使用。而CountDownLatch无法进行重复使用

@Test
    public void contextLoadss() throws Exception {
        CountDownLatch cyclicBarrier = new CountDownLatch(3);
        // 第一次执行3次
        for (int i = 0; i < 3; i++) {
            int j = i;
            executor.execute(() -> {
                try {
                    System.out.println("写执行耗时需要" + (j + 5 )+ "秒");
                    TimeUnit.SECONDS.sleep(j + 5);
                    cyclicBarrier.countDown();
                    System.out.println((j + 5 )+ "秒所有线程都执行完毕后继续进行执行");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
        cyclicBarrier.await();
        System.out.println("阻塞等待第一次全部执行");
        // 第二次执行3次
        for (int i = 0; i < 3; i++) {
            int j = i;
            executor.execute(() -> {
                try {
                    System.out.println("写执行耗时需要" + (j + 5 ) + "秒");
                    TimeUnit.SECONDS.sleep(j + 5);
                    cyclicBarrier.countDown();
                    System.out.println((j + 5 ) + "秒所有线程都执行完毕后继续进行执行");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
        cyclicBarrier.await();
        System.out.println("阻塞等待第二次全部完毕执行");
    }
// 结果:
写执行耗时需要6秒
写执行耗时需要7秒
写执行耗时需要5秒
5秒所有线程都执行完毕后继续进行执行
6秒所有线程都执行完毕后继续进行执行
7秒所有线程都执行完毕后继续进行执行
阻塞等待第一次全部执行
写执行耗时需要5秒
写执行耗时需要6秒
阻塞等待第二次全部完毕执行
写执行耗时需要7秒

从结果看出CountDownLatch 不可重用, 无法进行阻塞等待第二次3个线程

1