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

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();
 }
 }
}

 
 private final ReentrantLock lock = new ReentrantLock();
 
 private final Condition trip = lock.newCondition();
 
 private final int parties;
 
 private final Runnable barrierCommand;
 
 private Generation generation = new Generation();

 public int await() throws InterruptedException, BrokenBarrierException {
 try {
  return dowait(false, 0L);
 } catch (TimeoutException toe) {
  throw new Error(toe); // cannot happen
 }
 }
 
 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();
 }
 }