《Java源码分析》：CyclicBarrier（part one）

最新推荐文章于 2023-09-18 18:34:40 发布

HelloWorld_EE

最新推荐文章于 2023-09-18 18:34:40 发布

阅读量2.2k

点赞数 4

分类专栏： JAVA源码分析文章标签： java 源码 CyclicBarr

本文链接：https://blog.csdn.net/u010412719/article/details/52156588

版权

JAVA源码分析专栏收录该内容

52 篇文章 68 订阅

订阅专栏

《Java源码分析》：CyclicBarrier （part one）

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

举个例子哈：当我们10个人相约包车去成都玩，车早上就在学校门口等着我们10个人上车(规定只有10个人全部上车后才能开车出发)，现在陆陆续续的一个一个同学上车了，在第10个人到来之前，其它人都必须等待。在第10个人到来之后车就出发去成都了每个人就开始该干嘛就干嘛去了。

以上就是CyclicBarrier.

当然了，上面说的是正常不出意外的情况。CyclicBarrier和等车的例子一样，会出现各种情况(意外)：

例如：在车上等待的同学，突然有事(例如：老板打电话有事)不去玩了，则就会告诉所有人，我不去了哈，于是大家就都不需要等待了，各自下车去忙自己的事去。

还有一些情况，这里就不用例子一一来说明情况了。

CyclicBarrier常见的方法

有两个构造函数

CyclicBarrier(int parties)
创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，但它不会在启动 barrier 时执行预定义的操作。

CyclicBarrier(int parties, Runnable barrierAction)
创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，并在启动 barrier 时执行给定的屏障操作，该操作由最后一个进入 barrier 的线程执行。

int await()
在所有参与者都已经在此 barrier 上调用 await 方法之前，将一直等待。所有线程都到达barrier状态再同时执行后续任务；

int await(long timeout, TimeUnit unit)
在所有参与者都已经在此屏障上调用 await 方法之前将一直等待,或者超出了指定的等待时间。

下面先看几个关于CyclicBarrier的应用，然后再来从源码的角度来分析。

例子1

假设有3个线程，3个线程各自进行初始化，但是只有3个线程都初始化完成之后才使得3个线程同时继续运行干其它的工作。

先看利用CyclicBarrier(int parties) 构造对象并调用await() 进行等待的简单应用。

    public class CyclicBarrierDemo {
        private final static int NUM = 3;
        public static void main(String[] args) {
            final CyclicBarrier barrier = new CyclicBarrier(NUM);

            for(int i=0;i<NUM;i++){
                new Task(barrier).start();
            }

        }

        static class Task extends Thread{

            private CyclicBarrier barrier;
            public Task(CyclicBarrier barrier){
                this.barrier = barrier;
            }

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "  初始化开始。。。");
                try {
                    Thread.sleep(2000);//模拟初始化
                    System.out.println(Thread.currentThread().getName() + "  初始化结束，等待其他task初始化结束，然后再继续运行！");
                    barrier.await();//在所有线程均到达此barrier前，等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 其他task初始化结束，开始运行！");

            }

        }

    }

运行结果如下：

Thread-0  初始化开始。。。
Thread-1  初始化开始。。。
Thread-2  初始化开始。。。
Thread-0  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-2  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-1  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-2 其他task初始化结束，开始运行！
Thread-1 其他task初始化结束，开始运行！
Thread-0 其他task初始化结束，开始运行！

看了这个例子，CyclicBarrier是不是比较容易理解和应用。

例子2

在API文档中我们知道CyclicBarrier是可以重新利用的，通过下面这个例子就清楚了。

    public class CyclicBarrierDemo2 {
        private final static int NUM = 3;
        public static void main(String[] args) {
            final CyclicBarrier barrier = new CyclicBarrier(NUM);

            for(int i=0;i<NUM;i++){
                new Task(barrier).start();
            }

            try {
                Thread.sleep(20000);//等待其他线程执行完毕，当然我们这里可以选择使用CountDownLatch来实现。
                System.out.println("main线程休息结束！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //观察下CyclicBarrier是否可以复用
            for(int i=0;i<NUM;i++){
                new Task(barrier).start();
            }


        }

        static class Task extends Thread{

            private CyclicBarrier barrier;
            public Task(CyclicBarrier barrier){
                this.barrier = barrier;
            }

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "  初始化开始。。。");
                try {
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName() + "  初始化结束，等待其他task初始化结束，然后再继续运行！");
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 其他task初始化结束，开始运行！");

            }

        }

    }

运行结果如下：

Thread-1  初始化开始。。。
Thread-0  初始化开始。。。
Thread-2  初始化开始。。。
Thread-1  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-0  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-2  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-2 其他task初始化结束，开始运行！
Thread-1 其他task初始化结束，开始运行！
Thread-0 其他task初始化结束，开始运行！
main线程休息结束！
Thread-3  初始化开始。。。
Thread-4  初始化开始。。。
Thread-5  初始化开始。。。
Thread-4  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-3  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-5  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-5 其他task初始化结束，开始运行！
Thread-4 其他task初始化结束，开始运行！
Thread-3 其他task初始化结束，开始运行！

结论：从结果可以看出，CyclicBarrier确实是可以重用的。而CountDownLatch是不可以重用的

例子3

这个例子来看下 int await(long timeout, TimeUnit unit) 的应用。

让这些线程等待至一定的时间，如果还有线程没有到达barrier状态直接抛异常让到达barrier的线程执行后续任务。

    public class CyclicBarrierDemo3 {
        private final static int NUM = 3;
        public static void main(String[] args){
            final CyclicBarrier barrier = new CyclicBarrier(NUM);

            for(int i=0;i<NUM;i++){
                if(i==NUM-1){
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //先休息再开启线程
                    new Task(barrier).start();

                }
                else{
                    new Task(barrier).start();
                }

            }

        }

        static class Task extends Thread{

            private CyclicBarrier barrier;
            public Task(CyclicBarrier barrier){
                this.barrier = barrier;
            }

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "  初始化开始。。。");
                try {
                    Thread.sleep(2000);//模拟初始化
                    System.out.println(Thread.currentThread().getName() + "  初始化结束，等待其他task初始化结束，然后再继续运行！");
                    barrier.await(3, TimeUnit.SECONDS);//等待3秒，如果所有线程3秒后还没有到达barrier，则会抛异常然后继续往下面运行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 其他task初始化结束，开始运行！");

            }

        }

    }

运行结果如下：

Thread-1  初始化开始。。。
Thread-0  初始化开始。。。
Thread-1  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-0  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-2  初始化开始。。。
java.util.concurrent.TimeoutException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:257)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
    at com.wrh.readwritelock.CyclicBarrierDemo3$Task.run(CyclicBarrierDemo3.java:45)
Thread-0 其他task初始化结束，开始运行！
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
    at com.wrh.readwritelock.CyclicBarrierDemo3$Task.run(CyclicBarrierDemo3.java:45)
Thread-1 其他task初始化结束，开始运行！
Thread-2  初始化结束，等待其他task初始化结束，然后再继续运行！
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
    at com.wrh.readwritelock.CyclicBarrierDemo3$Task.run(CyclicBarrierDemo3.java:45)
Thread-2 其他task初始化结束，开始运行！

结论：从结果可以看出，如果使用await(time,unit);当到达时间后，还存在其他线程没有到达等待点，则已经到达等待点的线程就会直接抛异常继续往下面运行

例子4

下面当创建CyclicBarrier对象时，指定一个Runnable对象。即利用CyclicBarrier(int parties, Runnable barrierAction) 构造函数来构造一个对象。

    public class CyclicBarrierDemo4 {
        private final static int NUM = 3;
        public static void main(String[] args) {
            final CyclicBarrier barrier = new CyclicBarrier(NUM,new Runnable(){

                @Override
                public void run() {
                    try {
                        TimeUnit.SECONDS.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "  执行barrier自带的任务！");
                }

            });

            for(int i=0;i<NUM;i++){
                new Task(barrier).start();
            }

        }

        static class Task extends Thread{

            private CyclicBarrier barrier;
            public Task(CyclicBarrier barrier){
                this.barrier = barrier;
            }

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "  初始化开始。。。");
                try {
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName() + "  初始化结束，等待其他task初始化结束，然后再继续运行！");
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 其他task初始化结束，开始运行！");

            }

        }

    }

运行结果如下：

Thread-1  初始化开始。。。
Thread-0  初始化开始。。。
Thread-2  初始化开始。。。
Thread-1  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-0  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-2  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-0  执行barrier自带的任务！
Thread-0 其他task初始化结束，开始运行！
Thread-1 其他task初始化结束，开始运行！
Thread-2 其他task初始化结束，开始运行！

在线程中我故意将CyclicBarrier 中的sleep时间设置的相当长，发现结果是这样的。

当所有线程都到达barrier之后，然后调用CyclicBarrier自带的Runnable里面的run方法。
最后才是所有线程等待结束开始继续运行。

至于是哪个线程来执行CyclicBarrier对象中的任务就需要我们看下源码的实现了，在API文档上看到的是：最后一个进入到barrier的线程将执行。在源码中我们可以看到确实是最后一个线程来运行的，可以看后面的源码分析。

例子5

这个例子来看下，当创建CyclicBarrier对象时，指定一个Runnable对象。即利用CyclicBarrier(int parties, Runnable barrierAction) 构造函数来构造一个对象。

当最后一个进行barrier处的线程执行barrierAction时耗时特别长，且每个线程调用的是await(time,TimeUnit);会不会抛异常

    public class CyclicBarrierDemo5 {
        private final static int NUM = 3;
        public static void main(String[] args) {
            final CyclicBarrier barrier = new CyclicBarrier(NUM,new Runnable(){

                @Override
                public void run() {
                    try {
                        TimeUnit.SECONDS.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "  执行barrier自带的任务！");
                }

            });

            for(int i=0;i<NUM;i++){
                new Task(barrier).start();
            }

        }

        static class Task extends Thread{

            private CyclicBarrier barrier;
            public Task(CyclicBarrier barrier){
                this.barrier = barrier;
            }

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "  初始化开始。。。");
                try {
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName() + "  初始化结束，等待其他task初始化结束，然后再继续运行！");
                    barrier.await(2,TimeUnit.SECONDS);//等待两秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 其他task初始化结束，开始运行！");

            }

        }

    }

运行结果：

Thread-1  初始化开始。。。
Thread-0  初始化开始。。。
Thread-2  初始化开始。。。
Thread-1  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-0  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-2  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-0  执行barrier自带的任务！ 
Thread-0 其他task初始化结束，开始运行！
Thread-1 其他task初始化结束，开始运行！
Thread-2 其他task初始化结束，开始运行！

当代码换成barrier.await(2,TimeUnit.SECONDS);虽然此时CyclicBarrier对象中的Runnable的执行时间为20s，但是不会抛任何异常。这说明barrier.await(time,TimeUnit)方法等待的其它线程到达barrier的时间，而不包括执行CyclicBarrier对象中的Runnable的时间，在源码分析中，会介绍到。

例子6：CyclicBarrier指定的任务被运行时发生了异常

可能有人会考虑这样一个问题。

当我们利用CyclicBarrier(int parties, Runnable barrierAction) 构造函数指定barrierAction构造CyclicBarrier对象时，如果当最后一个到达barrier的线程执行barrierAction发生异常了会出现怎么样的结果呢？？

看下面这个例子你就明白了

    public class CyclicBarrierDemo6 {
        private final static int NUM = 3;
        public static void main(String[] args) {
            final CyclicBarrier barrier = new CyclicBarrier(NUM,new Runnable(){

                @Override
                public void run() {

                    System.out.println(Thread.currentThread().getName() + "  执行barrier自带的任务！此任务会抛异常");
                    int a = 1/0;//故意抛异常
                }

            });

            for(int i=0;i<NUM;i++){
                new Task(barrier).start();
            }

        }

        static class Task extends Thread{

            private CyclicBarrier barrier;
            public Task(CyclicBarrier barrier){
                this.barrier = barrier;
            }

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "  初始化开始。。。");
                try {
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName() + "  初始化结束，等待其他task初始化结束，然后再继续运行！");
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 其他task初始化结束，开始运行！");

            }

        }

    }

运行结果：

Thread-1  初始化开始。。。
Thread-0  初始化开始。。。
Thread-2  初始化开始。。。
Thread-1  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-0  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-2  初始化结束，等待其他task初始化结束，然后再继续运行！
Thread-0  执行barrier自带的任务！此任务会抛异常
Thread-2 其他task初始化结束，开始运行！
Thread-1 其他task初始化结束，开始运行！
Exception in thread "Thread-0" java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.wrh.readwritelock.CyclicBarrierDemo6$Task.run(CyclicBarrierDemo6.java:42)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.wrh.readwritelock.CyclicBarrierDemo6$Task.run(CyclicBarrierDemo6.java:42)
java.lang.ArithmeticException: / by zero
    at com.wrh.readwritelock.CyclicBarrierDemo6$1.run(CyclicBarrierDemo6.java:16)
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:220)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:362)
    at com.wrh.readwritelock.CyclicBarrierDemo6$Task.run(CyclicBarrierDemo6.java:42)

结论：当所有线程都到达barrier之后，然后调用CyclicBarrier自带的Runnable里面的run方法。
最后才是所有线程等待结束开始继续运行。当barrier 的任务抛异常，则只会在当前线程中传播，其它线程没有影响继续正常运行。

小结

需要我们了解的知识点有以下几点：

1、CyclicBarrier的用途是让一组线程互相等待，直到到达某个公共屏障点才开始继续工作。

2、CyclicBarrier是可以重复利用的，CountDownLatch不可以重复利用

3、在等待的只要有一个线程发生中断，则其它线程就会被唤醒继续正常运行。

4、CyclicBarrier指定的任务是进行barrier处最后一个线程来调用的，如果在执行这个任务发生异常时，则会传播到此线程，其它线程不受影响继续正常运行。

受篇幅限制，源码分析见下一篇博文哈。下一篇博文地址：http://blog.csdn.net/u010412719/article/details/52160438

HelloWorld_EE

关注

4
点赞
踩
14

收藏

觉得还不错? 一键收藏
2
评论
《Java源码分析》：CyclicBarrier（part one）

《Java源码分析》：CyclicBarrier （part one）CyclicBarrier字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了。举个例子哈：当我们10个人相约包车去成都玩，车早上就
复制链接

扫一扫