Java CountDownLatch计数器与CyclicBarrier循环屏障

CountDownLatch是一种同步辅助，允许一个或多个线程等待其他线程中正在执行的操作的ASET完成。它允许一组线程同时等待到达一个共同的障碍点

定义

CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.

CyclicBarrier: A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.

上述是Oracle官方定义。简单来说

CountDownLatch：计数器，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。

CyclicBarrier：循环屏障，它允许一组线程相互等待以达到一个共同的屏障点。

区别

CountDownLatch 是 AQS (AbstractQueuedSynchronizer) 的一员，但 CyclicBarrier 不是。
CountDownLatch 的使用场景中，有两类线程，一类是调用await()方法的等待线程，另一类是调用countDownl() 方法的操作线程。CyclicBarrier 的场景中，只有一类线程，都是相互等待的等待线程。
CountDownLatch 是减计数，递减完后不能复位，CyclicBarrier 是加计数，递增完后自动复位

CountDownLatch 示例

创建两组线程，一组等待另一组执行完才继续进行

CountDownLatch countDownLatch = new CountDownLatch(5); ExecutorService executorService = Executors.newCachedThreadPool(); for (int i = 0; i <5; i++) { executorService.execute(() -> { countDownLatch.countDown(); System.out.println("run.."); }); } for (int i = 0; i <3; i++) {  //我们要等上面执行完成才继续 executorService.execute(() -> { try { countDownLatch.await(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("await.."); }); } executorService.shutdown();

打印：

run..
run..
run..
run..
run..
await..
await..
await..

等待累加线程执行完，主线程再输出累加结果

public class ThreadUnsafeExample { private int cnt = 0; public void add() { cnt++; } public int get() { return cnt; } public static void main(String[] args) throws InterruptedException { final int threadSize = 1000; ThreadUnsafeExample example = new ThreadUnsafeExample(); final CountDownLatch countDownLatch = new CountDownLatch(threadSize); ExecutorService executorService = Executors.newCachedThreadPool(); for (int i = 0; i  { example.add(); countDownLatch.countDown(); }); } countDownLatch.await(); executorService.shutdown(); System.out.println(example.get()); } }

打印：

997

3 模拟并发

ExecutorService executorService = Executors.newCachedThreadPool(); CountDownLatch countDownLatch = new CountDownLatch(1); for (int i = 0; i <5; i++) { executorService.submit( () -> { try { countDownLatch.await(); System.out.println("【" + Thread.currentThread().getName() + "】开始执行……"); } catch (InterruptedException e) { e.printStackTrace(); } }); } Thread.sleep(2000); countDownLatch.countDown();//开始并发 executorService.shutdown();

打印：

【pool-2-thread-2】开始执行……
【pool-2-thread-5】开始执行……
【pool-2-thread-3】开始执行……
【pool-2-thread-1】开始执行……
【pool-2-thread-4】开始执行……

CyclicBarrier 示例

所有线程相互等待，直到某一步完成后再继续执行

        final int totalThread = 3; CyclicBarrier cyclicBarrier = new CyclicBarrier(3); ExecutorService executorService = Executors.newCachedThreadPool(); for (int i = 0; i  { System.out.println("before.."); try { cyclicBarrier.await(); } catch (InterruptedException | BrokenBarrierException e) { e.printStackTrace(); } System.out.println("after.."); }); } executorService.shutdown();

打印：