尽量把CyclicBarrier和CountDownLatch的区别说通俗点

转自https://www.iteye.com/blog/aaron-han-1591755

先说两点都知道的：
1.CountDownLatch减计数，CyclicBarrier加计数。
2.CountDownLatch是一次性的，CyclicBarrier可以重用。

然后我们用被大家说烂了的跑步的例子继续说事儿：

1. 有五个人，一个裁判。这五个人同时跑，裁判开始计时，五个人都到终点了，裁判喊停，然后统计这五个人从开始跑到最后一个撞线用了多长时间。

import java.util.concurrent.CountDownLatch;  
  
public class Race {  
  
    public static void main(String[] args) {  
        final int num = 5;  
        final CountDownLatch begin = new CountDownLatch(1);  
        final CountDownLatch end = new CountDownLatch(num);  
  
        for (int i = 0; i < num; i++) {  
            new Thread(new AWorker(i, begin, end)).start();  
        }  
  
        // judge prepare...  
        try {  
            Thread.sleep((long) (Math.random() * 5000));  
        } catch (InterruptedException e1) {  
            e1.printStackTrace();  
        }  
  
        System.out.println("judge say : run !");  
        begin.countDown();  
        long startTime = System.currentTimeMillis();  
  
        try {  
            end.await();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        } finally {  
            long endTime = System.currentTimeMillis();  
            System.out.println("judge say : all arrived !");  
            System.out.println("spend time: " + (endTime - startTime));  
        }  
  
    }  
  
}  
  
class AWorker implements Runnable {  
    final CountDownLatch begin;  
    final CountDownLatch end;  
    final int id;  
  
    public AWorker(final int id, final CountDownLatch begin,  
            final CountDownLatch end) {  
        this.id = id;  
        this.begin = begin;  
        this.end = end;  
    }  
  
    @Override  
    public void run() {  
        try {  
            System.out.println(this.id + " ready !");  
            begin.await();  
            // run...  
            Thread.sleep((long) (Math.random() * 10000));  
        } catch (Throwable e) {  
            e.printStackTrace();  
        } finally {  
            System.out.println(this.id + " arrived !");  
            end.countDown();  
        }  
    }  
  
}  

CountDownLatch强调的是一个线程（或多个）需要等待另外的n个线程干完某件事情之后才能继续执行。 上述例子，main线程是裁判，5个AWorker是跑步的。运动员先准备，裁判喊跑，运动员才开始跑（这是第一次同步，对应begin）。5个人谁跑到终点了，countdown一下，直到5个人全部到达，裁判喊停（这是第二次同步，对应end），然后算时间。

 

2. 继续，还是这五个人（这五个人真无聊..），这次没裁判。规定五个人只要都跑到终点了，大家可以喝啤酒。但是，只要有一个人没到终点，就不能喝。 这里也没有要求大家要同时起跑(当然也可以，加latch)。

import java.util.concurrent.BrokenBarrierException;  
import java.util.concurrent.CyclicBarrier;  
  
public class Beer {  
  
    public static void main(String[] args) {  
        final int count = 5;  
        final CyclicBarrier barrier = new CyclicBarrier(count, new Runnable() {  
            @Override  
            public void run() {  
                System.out.println("drink beer!");  
            }  
        });  
  
        // they do not have to start at the same time...  
        for (int i = 0; i < count; i++) {  
            new Thread(new Worker(i, barrier)).start();  
        }  
    }  
  
}  
  
class Worker implements Runnable {  
    final int id;  
    final CyclicBarrier barrier;  
  
    public Worker(final int id, final CyclicBarrier barrier) {  
        this.id = id;  
        this.barrier = barrier;  
    }  
  
    @Override  
    public void run() {  
        try {  
            System.out.println(this.id + "starts to run !");  
            Thread.sleep((long) (Math.random() * 10000));  
            System.out.println(this.id + "arrived !");  
            this.barrier.await();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        } catch (BrokenBarrierException e) {  
            e.printStackTrace();  
        }  
    }  
}  

 

CyclicBarrier强调的是n个线程，大家相互等待，只要有一个没完成，所有人都得等着。正如上例，只有5个人全部跑到终点，大家才能开喝，否则只能全等着。

再强调下，CountDownLatch强调一个线程等多个线程完成某件事情。CyclicBarrier是多个线程互等，等大家都完成。
 

 

 

面试考点
CyclicBarrier当所有线程都到达屏障点后，等待线程的执行顺序是什么样的？

CyclicBarrier的await方法是使用ReentrantLock和Condition控制实现的，使用的Condition实现类是ConditionObject，它里面有一个等待队列和await方法，这个await方法会向队列中加入元素。当调用CyclicBarrier的await方法会间接调用ConditionObject的await方法，当屏障关闭后首先执行指定的barrierAction，然后依次执行等待队列中的任务，有先后顺序。
————————————————
版权声明：本文为CSDN博主「gavin.jin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u012372941/article/details/93785920

 

 

1、概念

  CountDownLatch:具有计数器的功能，等待其他线程执行完毕，主线程在继续执行，用于监听某些初始化操作，并且线程进行阻塞，等初始化执行完毕后，通知主线程继续工作执行。值得注意的是CountDownLatch计数的次数一定要与构造器传入的数字一致，比如构造器传入的是3，则countDown()一定要执行3次，否则线程将一直阻塞。CountDownLatch通常用来控制线程等待，它可以让线程等待倒计时结束，再开始执行。
  CyclicBrrier：翻译过来就是循环栅栏的意思，其作用就是多线程的进行阻塞，等待某一个临界值条件满足后，同时执行！假设有一个场景：每个线程代表一个跑步运动员，当运动员都准备好后，才一起出发，只要有一个人没有准备好，大家都等待！

2、区别

  CountDownLatch: 一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行。
  CyclicBrrier: N个线程相互等待，任何一个线程完成之前，所有的线程都必须等待。