本文小编为大家详细介绍“Java CountDownLatch计数器与CyclicBarrier循环屏障怎么定义”，内容详细，步骤清晰，细节处理妥当，希望这篇“Java CountDownLatch计数器与CyclicBarrier循环屏障怎么定义”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。
定义
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 < threadSize; i++) {
executorService.execute(() -> {
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 < totalThread; i++) {
executorService.execute(() -> {
System.out.println("before..");
try {
cyclicBarrier.await();
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println("after..");
});
}
executorService.shutdown();
打印：
before..
before..
before..
after..
after..
after..
读到这里，这篇“Java CountDownLatch计数器与CyclicBarrier循环屏障怎么定义”文章已经介绍完毕，想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会，如果想了解更多相关内容的文章，欢迎关注***行业资讯频道。
