2.2 CyclicBarrier的理解和使用

快速理解：给所有线程加上了一个屏障，只有所有的线程都到达屏障之后（即cyclicbarrier初始值count=0），所有线程才会继续执行

CyclicBarrier的简单使用：初始cyclicBarrier是3，当三个线程都到达 屏障（即执行await()）之后，三个线程才能够自动执行

常用方法：下面都有使用示例

1、static CyclicBarrier cyclicBarrier = new CyclicBarrier(3);

2、static CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new CountSum());

3、cyclicBarrier.await();

最简单的示例：（没看资料之前自己凭理解完成的小demo，下面会有实际使用的例子）

 

public class MyCyclicBarrier {
    static CyclicBarrier cyclicBarrier = new CyclicBarrier(3);

    public static void main(String[] args) {
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"开始运行");
                System.out.println(Thread.currentThread().getName()+"到达屏障");
                Thread.sleep(1000);
                cyclicBarrier.await();

                System.out.println(Thread.currentThread().getName()+"所有线程到达屏障，"+ Thread.currentThread().getName()+"开始执行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"开始运行");
                System.out.println(Thread.currentThread().getName()+"到达屏障");
                Thread.sleep(500);
                cyclicBarrier.await();

                System.out.println(Thread.currentThread().getName()+"所有线程到达屏障，"+ Thread.currentThread().getName()+"开始执行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"开始运行");
                System.out.println(Thread.currentThread().getName()+"到达屏障");
                Thread.sleep(100);
                cyclicBarrier.await();

                System.out.println(Thread.currentThread().getName()+"所有线程到达屏障，"+ Thread.currentThread().getName()+"开始执行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }).start();
    }

}

执行结果：三个线程分别sleep时间不同，来模拟不同线程处理不同的任务，结果三个线程都执行await之后，三个线程才能能够继续执行

Thread-0开始运行
Thread-0到达屏障
Thread-1开始运行
Thread-1到达屏障
Thread-2开始运行
Thread-2到达屏障
Thread-0所有线程到达屏障，Thread-0开始执行
Thread-2所有线程到达屏障，Thread-2开始执行
Thread-1所有线程到达屏障，Thread-1开始执行

第二个小栗子：证明CyclicBarrier可以多次重复使用

 

public class MyCyclicBarrier {
    static CyclicBarrier cyclicBarrier = new CyclicBarrier(3);

    public static void main(String[] args) {
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"开始运行第一个任务");
                System.out.println(Thread.currentThread().getName()+"到达屏障");
                Thread.sleep(1000);
                cyclicBarrier.await();
                System.out.println(Thread.currentThread().getName()+"所有线程到达第一道屏障，"+ Thread.currentThread().getName()+"开始执行");
                System.out.println(Thread.currentThread().getName()+"开始执行第二个任务");
                Thread.sleep(1000);
                cyclicBarrier.await();
                System.out.println(Thread.currentThread().getName()+"所有线程到达第二道屏障，"+ Thread.currentThread().getName()+"开始执行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"开始运行第一个任务");
                System.out.println(Thread.currentThread().getName()+"到达屏障");
                Thread.sleep(500);
                cyclicBarrier.await();
                System.out.println(Thread.currentThread().getName()+"所有线程到达第一道屏障，"+ Thread.currentThread().getName()+"开始执行");
                System.out.println(Thread.currentThread().getName()+"开始执行第二个任务");
                Thread.sleep(500);
                cyclicBarrier.await();
                System.out.println(Thread.currentThread().getName()+"所有线程到达第二道屏障，"+ Thread.currentThread().getName()+"开始执行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"开始运行第一个任务");
                System.out.println(Thread.currentThread().getName()+"到达屏障");
                Thread.sleep(100);
                cyclicBarrier.await();
                System.out.println(Thread.currentThread().getName()+"所有线程到达第一道屏障，"+ Thread.currentThread().getName()+"开始执行");
                System.out.println(Thread.currentThread().getName()+"开始执行第二个任务");
                Thread.sleep(100);
                cyclicBarrier.await();
                System.out.println(Thread.currentThread().getName()+"所有线程到达第二道屏障，"+ Thread.currentThread().getName()+"开始执行");

            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }).start();
    }

}

运行结果：证明CyclicBarrier可以多次重复使用

Thread-0开始运行第一个任务
Thread-0到达屏障
Thread-1开始运行第一个任务
Thread-1到达屏障
Thread-2开始运行第一个任务
Thread-2到达屏障
Thread-0所有线程到达第一道屏障，Thread-0开始执行
Thread-0开始执行第二个任务
Thread-1所有线程到达第一道屏障，Thread-1开始执行
Thread-1开始执行第二个任务
Thread-2所有线程到达第一道屏障，Thread-2开始执行
Thread-2开始执行第二个任务
Thread-2所有线程到达第二道屏障，Thread-2开始执行

 

到达CyclicBarrier屏障时，设置优先执行的线程CyclicBarrier（int parties，Runnable barrierAction），从而对多个线程的计算结果汇总

代码示例：

public class MyCyclicBarrierCount {
    static CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new CountSum());
    static ConcurrentHashMap<Long, Integer> hashMap = new ConcurrentHashMap<>(3);

    static class CountAdd extends Thread {
        int start;
        int end;

        public CountAdd(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        public void run() {
            int sum = 0;
            for (int i = start; i <= end; i++) {
                sum = sum + i;
            }
            hashMap.put(Thread.currentThread().getId(), sum);
            System.out.println(Thread.currentThread().getName()+"计算完成了从"+start+"到"+end+"之和："+sum);
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"线程到达屏障，继续执行，但是会在CountSum（）执行完成之后才开始执行");
        }
    }

    static class CountSum extends Thread {

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+"CountSum（）执行完成之后，其他到达屏障的线程才会继续执行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int sum = 0;
            Set<Map.Entry<Long, Integer>> entries = hashMap.entrySet();
            for (Map.Entry<Long, Integer> entry : entries) {
                sum += entry.getValue();

            }
            System.out.println("从1加到100的总数是：" + sum);
        }
    }

    public static void main(String[] args) {
        new CountAdd(1,20).start();
        new CountAdd(21,60).start();
        new CountAdd(61,100).start();
    }

}

结果：计算结果之后，立马会执行static CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new CountSum());中的CountSum()线程

完全执行完成之后，其他到达屏障的线程才会继续执行

Thread-1计算完成了从1到20之和：210
Thread-3计算完成了从61到100之和：3220
Thread-2计算完成了从21到60之和：1620
Thread-2CountSum（）执行完成之后，其他到达屏障的线程才会继续执行
从1加到100的总数是：5050
Thread-2线程到达屏障，继续执行，但是会在CountSum（）执行完成之后才开始执行
Thread-1线程到达屏障，继续执行，但是会在CountSum（）执行完成之后才开始执行
Thread-3线程到达屏障，继续执行，但是会在CountSum（）执行完成之后才开始执行