面试知识点—多线程同步【2】之CyclicBarrier

继续总结多线程同步常用的方法或者类，上一节介绍了CountDownLatch，这次介绍一下它的加强版本CyclicBarriar。

CyclicBarriar–循环栅栏

CyclicBarriar的一个特别典型的应用场景是：有一个比较大型的任务，需要分配好多个人分多个阶段去执行，在每个阶段，需要每个人都参与，并且需要所有人在完成各自的子任务后才算完成这个阶段的工作，才能开始下一个阶段的子任务，最后所有阶段工作都完成后，才能执行主任务，这时候，就可以选择CyclicBarrier了。

1、CyclicBarriar的定义

CyclicBarrier也是在Java1.5中被引入的一个线程同步类。CyclicBarrier类似于CountDownLatch也是个计数器， 不同的是CyclicBarrier初始元素个数是调用了CyclicBarrier.await()进入等待的线程数， 当线程数达到了CyclicBarrier初始时规定的数目时，所有进入等待状态的线程被唤醒并继续，如此循环。
CyclicBarrier就象它名字的意思一样，可看成是个障碍。它允许一组线程互相等待，直到到达某个公共栅栏（屏障）点 (common barrier point)。在涉及需要多次并且多个线程进行互相等待时，所有的线程必须到齐后才能一起通过这个障碍点，CyclicBarrier将会非常有用。

2、基本元素和常用方法

CyclicBarrier(int parties)
      创建一个新的CyclicBarrier，parties表示有多少个数量的参与者参与。

CyclicBarrier(int parties, Runnable barrierAction)
      创建一个新的CyclicBarrier，parties表示有多少个数量的参与者参与。barrierAction会由最后一个进入 barrier 的参与者执行。
int await() 
      在所有参与者在调用 await方法之前，将一直等待。

int await(long timeout, TimeUnit unit) 
      在等待时间超过timeout之前，所有参与者在调用 await方法之前，将一直等待。unit表示等待时间的单位。

int getNumberWaiting() 
      返回当前在屏障处等待的参与者数目。

int getParties() 
      返回要求启动此barrier的参与者数目。

boolean isBroken() 
      查询此屏障是否处于损坏状态。

void    reset() 
      将屏障重置为其初始状态。

CyclicBarrier 类构造函数CyclicBarrier(int parties)有一个整数初始值，这个值表示将在同一个点需要同步的线程数量。当其中一个线程到达某个阶段点后，它会调用await() 方法来等待其他线程。调用这个方法后，CyclicBarrier阻塞线程进入休眠直到其他线程到达。当最后一个线程调用CyclicBarrier 类的await() 方法，它唤醒所有等待的线程并继续执行它们的任务。然后如此循环。
CyclicBarrier 类的另一个构造函数CyclicBarrier(int parties, Runnable barrierAction)初始时还可带一个Runnable的参数，此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。

3、演示代码

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestCyclicBarrier {
    public static void main(String [] args){
        ExecutorService service= Executors.newCachedThreadPool();
        final CyclicBarrier cb=new CyclicBarrier(3);  //三个线程同时到达
        MyRunnable myRunnable1 = new MyRunnable("张三", cb);
        service.execute(myRunnable1);
        MyRunnable myRunnable2 = new MyRunnable("赵四", cb);
        service.execute(myRunnable2);
        MyRunnable myRunnable3 = new MyRunnable("李五", cb);
        service.execute(myRunnable3);
        service.shutdown();
    }
    public void reachSchedule(String name, CyclicBarrier cb){
        try{
            Thread.sleep((long)(Math.random()*10000));
            System.out.println(name+
                    "到达公园，当前共有"+(cb.getNumberWaiting()+1)+"个已到达"+
                    (cb.getNumberWaiting()==2 ? "，到齐了，然后向公园门口出发！":"正在等候"));
            try {
                cb.await();
            } catch (BrokenBarrierException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public void reachPark(String name, CyclicBarrier cb){
        try{
            Thread.sleep((long)(Math.random()*10000));
            System.out.println(name+
                    "到达公园，当前共有"+(cb.getNumberWaiting()+1)+"个已到达"+
                    (cb.getNumberWaiting()==2 ? "，都到公园了，发票开始玩，然后向饭店出发！":"正在等候"));
            try {
                cb.await();
            } catch (BrokenBarrierException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public void reachHotel(String name, CyclicBarrier cb){
        try{
            Thread.sleep((long)(Math.random()*10000));
            System.out.println(name+
                    "到达公园，当前共有"+(cb.getNumberWaiting()+1)+"个已到达"+
                    (cb.getNumberWaiting()==2 ? "，都到饭店了，开始吃饭！":"正在等候"));
            try {
                cb.await();
            } catch (BrokenBarrierException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    static class MyRunnable implements Runnable {
        private String name;
        private CyclicBarrier cb;
        MyRunnable(String name, CyclicBarrier cb){
            this.name = name;
            this.cb = cb;
        }
        @Override
        public void run() {
            //先到学校
            reachSchedule(name);
            //再到公园
            reachPark(name);
            //最后到饭店
            reachHotel(name);
        }
    }
}

运行结果：

赵四到达学校，当前共有1个已到达，等着吧。
张三到达学校，当前共有2个已到达，等着吧。
李五到达学校，当前共有3个已到达，到齐了，然后向公园门口出发！
张三到达公园，当前共有1个已到达，等着吧。
李五到达公园，当前共有2个已到达，等着吧。
赵四到达公园，当前共有3个已到达，都到公园了，发票开始玩，结束后向饭店出发！
赵四到达旅馆，当前共有1个已到达，等着吧。
李五到达旅馆，当前共有2个已到达，等着吧。
张三到达旅馆，当前共有3个已到达，都到饭店了，开始吃饭！

4、CountDownLatch和CyclicBarrier比较

● CountDownLatch的作用是允许1或N个线程等待其他线程完成执行；而CyclicBarrier则是允许N个线程相互等待。

● CountDownLatch的计数器无法被重置，只能作为一次性的barrier使用；而CyclicBarrier的计数器可以被重置继续使用，因此它被称为是循环的barrier。

● CyclicBarrier可以替换CountDownLatch来使用，但是反过来行不通。

5、总结

如果是简单的一次性的多个或者一个线程同步，那使用CountDownLatch会很方便，本司机在日常开发中经常使用CountDownLatch处理两个线程的同步问题，真的是比较方便。如果是多个线程并需要多次同步时，可以考虑使用CyclicBarrier，目前本司机还没有在实际项目中使用过。

本公众号将以推送Android各种碎片化小知识或小技巧，以及整理老司机日常工作中踩过的坑涉及到的知识点为主，也会不定期将正在学习使用的React Native一些知识点总结出来进行分享。每天一点干货小知识把你的碎片时间充分利用起来。