了解循环屏障CyclicBarrier

「爱情、让人受尽委屈。」 2022-05-17 08:11 303阅读 0赞

**CyclicBarrier是常用的同步辅助工具类，它的作用是让一组线程达到屏障点时被阻塞，直到指定数量的线程都达到屏障点，才取消阻塞，此时被阻塞的线程才能继续执行。循环屏障可以重复使用。**

**SyclicBarrier构造方法有两个CyclicBarrier(int parties)和CyclicBarrier(int parties, Runnable barrierAction)。第一个参数parties指定可以打开屏障的线程数量，第二个参数barrierAction指定一旦打开屏障就会执行(非立即)的操作。**

**只有调用await()方法的线程才会达到屏障点进行等待，当等待的线程数量达到循环屏障设置的值parties，屏障才会打开，并执行打开屏障的操作。而getNumberWaiting()方法返回当前阻塞的线程数量。**

如下模拟一个循环屏障反复使用的实例：5个学生相约一起赶校车，一起上学，一起点名，一起学习。

public class TestCyclicBarrier {
    
        public static void main(String[] args) throws InterruptedException {
            System.out.println("太阳公公出门啦");
            CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new BarrierPoint(0));
            for (int i = 0; i < 5; i++) {
                Thread thread = new Thread(new Student(i + "号学生", cyclicBarrier));
                thread.start();
            }
        }
    
        static class BarrierPoint implements Runnable {
            private int id;
    
            public BarrierPoint(int id) {
                this.id = id;
            }
    
            @Override
            public void run() {
                if (id == 0) {
                    System.out.println("发车啦");
                    id = 1;
                    return;
                }
                if (id == 1) {
                    System.out.println("开始点名");
                    id = 2;
                    return;
                }
                if (id == 2) {
                    System.out.println("准备上课");
                    return;
                }
            }
        }
    
        static class Student implements Runnable {
            private String name;
            private CyclicBarrier cyclicBarrier;
    
            public Student(String name, CyclicBarrier cyclicBarrier) {
                this.name = name;
                this.cyclicBarrier = cyclicBarrier;
            }
    
            @Override
            public void run() {
                try {
                    Thread.sleep((long) (Math.random() * 2000 + 1000));
                    System.out.println(name + "开始上车");
                    cyclicBarrier.await();
                    Thread.sleep((long) (Math.random() * 2000 + 1000));
                    System.out.println(name + "进入教室");
                    cyclicBarrier.await();
                    Thread.sleep((long) (Math.random() * 2000 + 1000));
                    System.out.println(name + "翻开课本");
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }
    }

控制台输出的执行结果如下：

太阳公公出门啦  
1号学生开始上车  
3号学生开始上车  
0号学生开始上车  
4号学生开始上车  
2号学生开始上车  
发车啦  
0号学生进入教室  
1号学生进入教室  
4号学生进入教室  
2号学生进入教室  
3号学生进入教室  
开始点名  
1号学生翻开课本  
4号学生翻开课本  
0号学生翻开课本  
3号学生翻开课本  
2号学生翻开课本  
准备上课

在这个案例中，由于await()方法调用了3次，所以5条线程都被阻塞了3次。第一次发生阻塞是由于校车需要等待这5个学生都上车了才可以发车，第二次阻塞是由于5个学生都需要到达教室才能开始点名，第三次阻塞是由于5个学生都准备好课本老师才开始讲课。

本例中通过BarrierPoint来维护每次打开屏障需要执行的操作，由于每次打开屏障所执行的操作都可能不一样，所以通过id来标识具体的操作内容。

**如果调用await()方法的线程数量大于循环屏障设置的值，被阻塞的线程将永远阻塞。且屏障打开后的操作线程不是立即执行的。**

以下是一个模拟永远阻塞的实例：

public class TestCyclicBarrier2 {
    
        public static void main(String[] args) {
            CyclicBarrier cb = new CyclicBarrier(3, new Runnable() {
                @Override
                public void run() {
                    System.out.println("屏障打开");
                }
            });
            for (int i = 0; i < 10; i++) {
                Thread worker = new Thread(new Worker(cb));
                worker.start();
            }
        }
    
        static class Worker implements Runnable {
            private CyclicBarrier cb;
    
            public Worker(CyclicBarrier cb) {
                super();
                this.cb = cb;
            }
    
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread().getName() + "到达屏障");
                    cb.await();
                    Thread.sleep(2000);
                    System.out.println("屏障等待的线程数量：" + cb.getNumberWaiting());
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }
    }

控制台输入如下：

Thread-0到达屏障  
Thread-1到达屏障  
Thread-3到达屏障  
Thread-2到达屏障  
Thread-4到达屏障  
屏障打开  
Thread-5到达屏障  
屏障打开  
Thread-6到达屏障  
Thread-9到达屏障  
Thread-7到达屏障  
屏障打开  
Thread-8到达屏障  
屏障等待的线程数量：1  
屏障等待的线程数量：1  
屏障等待的线程数量：1  
屏障等待的线程数量：1  
屏障等待的线程数量：1  
屏障等待的线程数量：1  
屏障等待的线程数量：1  
屏障等待的线程数量：1  
屏障等待的线程数量：1

可以看出控制台输出这些内容后没有停止而是一直运行，因为有一个线程阻塞了，那就是Thread-8。我们创建了10条线程，但是循环屏障只能同时让3条线程互相等待，所以有9条线程执行完毕后，必然有剩余1条线程到达屏障时被阻塞，此处Thread-8就是那条很不幸被永久阻塞的线程。

另外从输出内容看，输出【屏障打开】的语句间歇性每隔3个线程就执行，这是为什么呢？

之前有提到过 **屏障打开后的操作线程不是立即执行的。**本例中 【Thread-0到达屏障】，【Thread-1到达屏障】，【Thread-3到达屏障】后其实循环屏障已经打开了，但是【Thread-2到达屏障】和【Thread-4到达屏障】的线程抢先执行，所以【屏障打开】这个执行线程慢了一拍就导致看到图中的输出效果。同理可以分析后面输出错乱的原因。但无论如何Thread-8是被永久阻塞的线程，这个结论肯定是没错的，因为先到达屏障的线程先释放。

**另外 CountDownLatch和CyclicBarrier 是比较相似的，但有明显的不同点：**

**CountDownLatch必须通过countDown和await方法协同工作控制阻塞时机，且CountDownLatch是一次性的，不能被复位。**

**CyclicBarrier只需调用await方法就能控制阻塞时机，且CyclicBarrier的await方法是可以重复使用的，每次屏障打开后可以自动关闭，以实现下次继续阻塞的效果。**