并发编程常用工具类(一) countDownLatch和cyclicBarrier的使用对比

1.CountDownLatch

          countDownLatch的作用是让一组线程等待其他线程完成工作以后在执行，相当于加强版的join(不懂可以百度一下join的用法)，一般在初始化的时候会在构造方法传入计数器，

后续，在其他线程中每次调用countDown方法计数器减一，一般在需要等待的线程中调用countDownLatch的await方法阻塞线程，在当计数器为0时，等待线程继续运行。

          光看上面的定义描述不是很直观，我们再来结合代码看一下实际运用：

public class UseCountDownLatch {
    
    static CountDownLatch latch = new CountDownLatch(6);
    //初始化线程(只有一步，有4个)
    private static class InitThread implements Runnable{

        @Override
        public void run() {
            System.out.println("Thread_"+Thread.currentThread().getId()
                    +" ready init work......");
            latch.countDown();//初始化线程完成工作了，countDown方法只扣减一次；
            for(int i =0;i<2;i++) {
                System.out.println("Thread_"+Thread.currentThread().getId()
                        +" ........continue do its work");
            }
        }
    }
    //业务线程
    private static class BusiThread implements Runnable{

        @Override
        public void run() {
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for(int i =0;i<3;i++) {
                System.out.println("BusiThread_"+Thread.currentThread().getId()
                        +" do business-----");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //单独的初始化线程,初始化分为2步，需要扣减两次
        new Thread(new Runnable() {
            @Override
            public void run() {
                SleepTools.ms(1);
                System.out.println("Thread_"+Thread.currentThread().getId()
                        +" ready init work step 1st......");
                latch.countDown();//每完成一步初始化工作，扣减一次
                System.out.println("begin step 2nd.......");
                SleepTools.ms(1);
                System.out.println("Thread_"+Thread.currentThread().getId()
                        +" ready init work step 2nd......");
                latch.countDown();//每完成一步初始化工作，扣减一次
            } 
        }).start();
        new Thread(new BusiThread()).start();
        for(int i=0;i<=3;i++){
            Thread thread = new Thread(new InitThread());
            thread.start();
        }

        latch.await();
        System.out.println("Main do ites work........");
    }
}

运行结果可以看到，两个初始化线程先跑，当两个初始化线程跑完了，latch的计数器减为0，阻塞放开，主线程和业务线程继续往下运行。但是，在设计这部分算法的时候需要注意，有可能会出现计数器没有减为0，则线程一直阻塞，导致程序卡死。

          countDownLatch一般使用在多线程并发之后需要对结果进行处理，而我们无法控制所有线程的执行时间，所以在这里加上阻塞，等到只有线程全部执行完。

2.CyclicBarrier

          cyclicBarrier从业务角度来说，和countDownLatch比较类似(具体对比后面会专门介绍)，其作用类似一个屏障(英文中也是屏障的意思)，阻隔线程直到全部到达屏障点，放开屏障。一般可以用在多线程统计的时候，

          从代码角度来看，cyclicBarrier有两个构造方法，CyclicBarrier(int parties)和CyclicBarrier(int parties, Runnable barrierAction)；

          两个方法的区别是第一个只是记录了线程计数器的个数，而第二个不仅记录了计数器，当屏障放开时，会执行第二个参数线程的方法(第二个参数一般传入的是一个实现了Runnable的线程方法)

再来结合代码深入了解一下：

          

public class UseCyclicBarrier {
    
    private static CyclicBarrier barrier 
        = new CyclicBarrier(5,new CollectThread());
    
    private static ConcurrentHashMap<String,Long> resultMap
            = new ConcurrentHashMap<>();//存放子线程工作结果的容器

    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                long id = Thread.currentThread().getId();//线程本身的处理结果
                resultMap.put(Thread.currentThread().getId()+"",id);
                Random r = new Random();//随机决定工作线程的是否睡眠
                try {
                    if(r.nextBoolean()) {
                        Thread.sleep(2000+id);
                        System.out.println("Thread_"+id+" ....do something ");
                    }
                    System.out.println(id+"....is await");
                    barrier.await();
                    Thread.sleep(1000+id);
                    System.out.println("Thread_"+id+" ....do its business ");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }.start();
        for(int i=0;i<=3;i++){
            Thread thread = new Thread(new SubThread());
            thread.start();
        }
    }

    //负责屏障开放以后的工作
    private static class CollectThread implements Runnable{

        @Override
        public void run() {
            StringBuilder result = new StringBuilder();
            for(Map.Entry<String,Long> workResult:resultMap.entrySet()){
                result.append("["+workResult.getValue()+"]");
            }
            System.out.println(" the result = "+ result);
            System.out.println("do other business........");
        }
    }

    //工作线程
    private static class SubThread implements Runnable{

        @Override
        public void run() {
            long id = Thread.currentThread().getId();//线程本身的处理结果
            resultMap.put(Thread.currentThread().getId()+"",id);
            Random r = new Random();//随机决定工作线程的是否睡眠
            try {
                if(r.nextBoolean()) {
                    Thread.sleep(2000+id);
                    System.out.println("Thread_"+id+" ....do something ");
                }
                System.out.println(id+"....is await");
                barrier.await();
                Thread.sleep(1000+id);
                System.out.println("Thread_"+id+" ....do its business ");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

   输出结果：       11....is await
                            12....is await
                             Thread_10 ....do something
                     10....is await
Thread_13 ....do something
13....is await
Thread_14 ....do something
14....is await
 the result = [11][12][13][14][10]
do other business........
Thread_10 ....do its business
Thread_11 ....do its business
Thread_12 ....do its business
Thread_13 ....do its business
Thread_14 ....do its business

3.countDownLatch和cyclicBarrier区别

        （1）countDownlatch的计数器由调用countDown方法次数决定，每次调用计数器减一，可以在一个线程中调用多次，而cyclicBarrier计数器取决调用await方法的线程个数。

          (2)  countDownLatch只能用一次，而cyclicBarrier可以循环使用。并且cyclicBarrier可以调用reset方法重置计数器，可以在线程故障重新启用线程调用。

          (3)  二者在内部方法也有很多区别，具体有兴趣的可以去看看源码。

 参考文章：http://ifeve.com/concurrency-cyclicbarrier/