CountDownLatch与CyclicBarrier的对比

CountDownLatch：

CountDownLatch通过计数器来实现，计数器表示线程的数量。每当一个线程执行结束后，计数器的值就会减1，并在await方法处阻塞。一旦计数器为0，所有阻塞的线程均被释放，await方法后所有后续动作都会开始执行。计数器无法被重置。

并发模拟CountDownLatch

 import java.util.concurrent.CountDownLatch;

 public class CountRunnable implements Runnable {
     private CountDownLatch countDownLatch;

     public CountRunnable(CountDownLatch countDownLatch) {
         this.countDownLatch = countDownLatch;
     }

     @Override
     public void run() {
         try {
             synchronized (countDownLatch) {
                 countDownLatch.countDown();
                 System.out.println("down latch count = " + countDownLatch.getCount());
             }
             countDownLatch.await();
             System.out.println("current count = " + (5 - countDownLatch.getCount()));
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 }

 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;

 public class CountDownTest {
     public static void main(String[] args) {
         ExecutorService pool = Executors.newCachedThreadPool();
         CountDownLatch cdl = new CountDownLatch(5);
         for (int i = 0; i < 5; i++) {
             CountRunnable countRunnable = new CountRunnable(cdl);
             pool.execute(countRunnable);
         }
     }
 }

控制台输出：

down latch count = 4
down latch count = 3
down latch count = 2
down latch count = 1
down latch count = 0
current count = 5
current count = 5
current count = 5
current count = 5
current count = 5

 观察到线程countDownLatch.countDown()方法后阻塞在await方法处，当所有线程都执行countDownLatch.countDown()方法后，即计数器count减为0后，每个线程的await()方法就会立刻return，从而执行之后的方法

CyclicBarrier：

CyclicBarrier可以协同多个线程，每个线程到达这个屏障处时都会等待，直到所有线程都到达了这个屏障时，再一起继续执行后面的动作。

模拟CyclicBarrier

 import java.util.concurrent.CyclicBarrier;

 public class CyclicBarrierThread extends Thread {
     private CyclicBarrier cb;

     private int sleepSecond;

     public CyclicBarrierThread(CyclicBarrier cb, int sleepSecond) {
         this.cb = cb;
         this.sleepSecond = sleepSecond;
     }

     public CyclicBarrier getCb() {
         return cb;
     }

     public void setCb(CyclicBarrier cb) {
         this.cb = cb;
     }

     public int getSleepSecond() {
         return sleepSecond;
     }

     public void setSleepSecond(int sleepSecond) {
         this.sleepSecond = sleepSecond;
     }

     public void run() {
         try {
             System.out.println(this.getName() + "start run ...");
             Thread.sleep(sleepSecond * 1000);
             System.out.println(this.getName() + "start to wait, time is " + System.currentTimeMillis());
             cb.await();
             System.out.println(this.getName() + "end wait, time is " + System.currentTimeMillis());
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }

 import java.util.concurrent.CyclicBarrier;

 public class Test {
     public static void main(String[] args) throws Exception {
         Runnable runnable = new Runnable() {
             @Override
             public void run() {
                 System.out.println("CyclicBarrier的所有线程await()结束了，开始指定的Runnable运行, 时间为" + System.currentTimeMillis());
             }
         };

         CyclicBarrier cb = new CyclicBarrier(3, runnable);
         CyclicBarrierThread cbt0 = new CyclicBarrierThread(cb, 3);
         CyclicBarrierThread cbt1 = new CyclicBarrierThread(cb, 6);
         CyclicBarrierThread cbt2 = new CyclicBarrierThread(cb, 9);
         cbt0.start();
         cbt1.start();
         cbt2.start();
     }
 }

控制台输出

Thread-1 start run ...
Thread-2 start run ...
Thread-0 start run ...
Thread-0 start to wait, time is 1575901627885
Thread-1 start to wait, time is 1575901630884
Thread-2 start to wait, time is 1575901633886
CyclicBarrier的所有线程await()结束了，开始指定的Runnable运行, 时间为1575901633886
Thread-2 end wait, time is 1575901633886
Thread-0 end wait, time is 1575901633886
Thread-1 end wait, time is 1575901633886

观察到所有线程都运行到了await()方法的时候，所有线程后面的代码以及指定的Runnable同时运行

综上：

1.CountDownLatch本质是一个计数器，线程执行一次，计数器减一，只能单次使用；而CyclicBarrier类似阀门或者栅栏，需要所有线程都到达，然后才能继续执行，可以多次使用

2.CountDownLatch当调用countDown()方法后的计数器等于指定的线程数之后，可以唤起多个线程的任务；而CyclicBarrier当执行到await()方法的线程数量等于指定的parties数量之后，只能唤起一个BarrierAction