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