解析阿里一面CyclicBarrier和CountDownLatch的区别

引言

前面一篇文章我们《java线程并发工具类countdownlatch原理及用法》它有一个缺点，就是它的计数器只能够使用一次，也就是说当计数器（state）减到为 0的时候，如果 再有线程调用去 await() 方法，该线程会直接通过，不会再起到等待其他线程执行结果起到同步的作用。为了解决这个问题cyclicbarrier就应运而生了。

什么是cyclicbarrier

cyclicbarrier是什么？把它拆开来翻译就是循环（cycle）和屏障（barrier）

它的主要作用其实和countdownlanch差不多，都是让一组线程到达一个屏障时被阻塞，直到最后一个线程到达屏障时，屏障会被打开，所有被屏障阻塞的线程才会继续执行，不过它是可以循环执行的，这是它与countdownlanch最大的不同。countdownlanch是只有当最后一个线程把计数器置为0的时候，其他阻塞的线程才会继续执行。学习cyclicbarrier之前建议先去看看这几篇文章：

《java高并发编程基础之aqs》

《java高并发编程基础三大利器之semaphore》

《java高并发编程基础三大利器之countdownlatch》

如何使用

我们首先先来看下关于使用cyclicbarrier的一个demo：比如游戏中有个关卡的时候，每次进入下一关的时候都需要进行加载一些地图、特效背景音乐什么的只有全部加载完了才能够进行游戏:

public class cyclicbarrierexample {
 static class pretaskthread implements runnable {
 private string task;
 private cyclicbarrier cyclicbarrier;

 public pretaskthread(string task, cyclicbarrier cyclicbarrier) {
  this.task = task;
  this.cyclicbarrier = cyclicbarrier;
 }

 @override
 public void run() {
  for (int i = 0; i < 4; i++) {
  random random = new random();
  try {
   thread.sleep(random.nextint(1000));
   system.out.println(string.format("关卡 %d 的任务 %s 完成", i, task));
   cyclicbarrier.await();
  } catch (interruptedexception | brokenbarrierexception e) {
   e.printstacktrace();
  }
  }
 }

 public static void main(string[] args) {
  cyclicbarrier cyclicbarrier = new cyclicbarrier(3, () -> {
  system.out.println("本关卡所有的前置任务完成，开始游戏... ...");
  });
  new thread(new pretaskthread("加载地图数据", cyclicbarrier)).start();
  new thread(new pretaskthread("加载人物模型", cyclicbarrier)).start();
  new thread(new pretaskthread("加载背景音乐", cyclicbarrier)).start();
 }
 }
}

输出结果如下：

我们可以看到每次游戏开始都会等当前关卡把游戏的人物模型，地图数据、背景音乐加载完成后才会开始进行游戏。并且还是可以循环控制的。

源码分析

结构组成

 /** the lock for guarding barrier entry */
 private final reentrantlock lock = new reentrantlock();
 /** condition to wait on until tripped */
 private final condition trip = lock.newcondition();
 /** the number of parties */
 private final int parties;
 /* the command to run when tripped */
 private final runnable barriercommand;
 /** the current generation */
 private generation generation = new generation();

• lock:用于保护屏障入口的锁
• trip :达到屏障并且不能放行的线程在trip条件变量上等待
• parties :栅栏开启需要的到达线程总数barriercommand：最后一个线程到达屏障后执行的回调任务
• generation：这是一个内部类，通过它实现cyclicbarrier重复利用，每当await达到最大次数的时候，就会重新new 一个，表示进入了下一个轮回。里面只有一个boolean型属性，用来表示当前轮回是否有线程中断。

主要方法

await方法

 public int await() throws interruptedexception, brokenbarrierexception {
 try {
  return dowait(false, 0l);
 } catch (timeoutexception toe) {
  throw new error(toe); // cannot happen
 }
 }
 /**
 * main barrier code, covering the various policies.
 */
 private int dowait(boolean timed, long nanos)
 throws interruptedexception, brokenbarrierexception,
  timeoutexception {
 final reentrantlock lock = this.lock;
 lock.lock();
  try {
  //获取barrier当前的 “代”也就是当前循环
  final generation g = generation;
  if (g.broken)
  throw new brokenbarrierexception();

  if (thread.interrupted()) {
  breakbarrier();
  throw new interruptedexception();
  }
  // 每来一个线程调用await方法都会进行减1
  int index = --count;
  if (index == 0) { // tripped
  boolean ranaction = false;
  try {
   final runnable command = barriercommand;
   // new cyclicbarrier 传入 的barriercommand, command.run()这个方法是同步的，如果耗时比较多的话,是否执行的时候需要考虑下是否异步来执行。
   if (command != null)
   command.run();
   ranaction = true;
   // 这个方法1. 唤醒所有阻塞的线程，2. 重置下count（count 每来一个线程都会进行减1）和generation，以便于下次循环。
   nextgeneration();
   return 0;
  } finally {
   if (!ranaction)
   breakbarrier();
  }
  }

  // loop until tripped, broken, interrupted, or timed out
  for (;;) {
  try {
   // 进入if条件，说明是不带超时的await
   if (!timed)
    // 当前线程会释放掉lock，然后进入到trip条件队列的尾部，然后挂起自己，等待被唤醒。
   trip.await();
   else if (nanos > 0l)
    //说明当前线程调用await方法时 是指定了 超时时间的！
   nanos = trip.awaitnanos(nanos);
  } catch (interruptedexception ie) {
   //node节点在 条件队列内 时 收到中断信号时 会抛出中断异常！
   //g == generation 成立，说明当前代并没有变化。
   //! g.broken 当前代如果没有被打破，那么当前线程就去打破，并且抛出异常..
   if (g == generation && ! g.broken) {
   breakbarrier();
   throw ie;
   } else {
   // we're about to finish waiting even if we had not
   // been interrupted, so this interrupt is deemed to
   // "belong" to subsequent execution.
   //执行到else有几种情况？
   //1.代发生了变化，这个时候就不需要抛出中断异常了，因为 代已经更新了，这里唤醒后就走正常逻辑了..只不过设置下 中断标记。
   //2.代没有发生变化，但是代被打破了，此时也不用返回中断异常，执行到下面的时候会抛出 brokenbarrier异常。也记录下中断标记位。
   thread.currentthread().interrupt();
   }
  }
  //唤醒后，执行到这里，有几种情况？
  //1.正常情况，当前barrier开启了新的一代（trip.signalall()）
  //2.当前generation被打破，此时也会唤醒所有在trip上挂起的线程
  //3.当前线程trip中等待超时，然后主动转移到 阻塞队列 然后获取到锁 唤醒。
  if (g.broken)
   throw new brokenbarrierexception();
  //唤醒后，执行到这里，有几种情况？
  //1.正常情况，当前barrier开启了新的一代（trip.signalall()）
  //2.当前线程trip中等待超时，然后主动转移到 阻塞队列 然后获取到锁 唤醒。
  if (g != generation)
   return index;
  //唤醒后，执行到这里，有几种情况？
  //.当前线程trip中等待超时，然后主动转移到 阻塞队列 然后获取到锁 唤醒。
  if (timed && nanos <= 0l) {
   breakbarrier();
   throw new timeoutexception();
  }
  }
 } finally {
  lock.unlock();
 }
 }

小结

到了这里我们是不是可以知道为啥cyclicbarrier可以进行循环计数？
cyclicbarrier采用一个内部类generation来维护当前循环，每一个await方法都会存储当前的generation，获取到相同generation对象的属于同一组，每当count的次数耗尽就会重新new一个generation并且重新设置count的值为parties，表示进入下一次新的循环。
从这个await方法我们是不是可以知道只要有一个线程被中断了，当代的 generation的broken 就会被设置为true，所以会导致其他的线程也会被抛出brokenbarrierexception。相当于一个失败其他也必须失败，感觉有“强一致性“的味道。

总结

countdownlanch是为计数器是设置一个值，当多次执行countdown后，计数器减为0的时候所有线程被唤醒，然后countdownlanch失效，只能够使用一次。

cyclicbarrier是当count为0时同样唤醒全部线程，同时会重新设置count为parties，重新new一个generation来实现重复利用。

结束

• 由于自己才疏学浅，难免会有纰漏，假如你发现了错误的地方，还望留言给我指出来,我会对其加以修正。
• 如果你觉得文章还不错，你的转发、分享、赞赏、点赞、留言就是对我最大的鼓励。感
• 谢您的阅读,十分欢迎并感谢您的关注。

巨人的肩膀摘苹果

到此这篇关于阿里一面cyclicbarrier和countdownlatch的区别是啥的文章就介绍到这了,更多相关cyclicbarrier和countdownlatch的区别内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！