CyclicBarrier与CountDownLatch

CountDownLatch （倒计时器）

CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行。在Java并发中，countdownlatch的概念是一个常见的面试题，所以一定要确保你很好的理解了它。

CountDownLatch 的三种典型用法

①某一线程在开始运行前等待n个线程执行完毕。将 CountDownLatch 的计数器初始化为n ：new CountDownLatch(n)，每当一个任务线程执行完毕，就将计数器减1 countdownlatch.countDown()，当计数器的值变为0时，在CountDownLatch上 await()的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。

②实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的 CountDownLatch对象，将其计数器初始化为 1 ：new CountDownLatch(1)，多个线程在开始执行任务前首先 coundownlatch.await()，当主线程调用 countDown() 时，计数器变为0，多个线程同时被唤醒。

③死锁检测：一个非常方便的使用场景是，你可以使用n个线程访问共享资源，在每次测试阶段的线程数目是不同的，并尝试产生死锁。

CountDownLatch 的使用示例

/**
 * 
 * @authorSnailClimb
 * @date2018年10月1日* @Description: CountDownLatch 使用方法示例*/publicclassCountDownLatchExample1{
  // 请求的数量privatestaticfinalintthreadCount = 550;

  publicstaticvoidmain(String[] args)throwsInterruptedException {
    // 创建一个具有固定线程数量的线程池对象（如果这里线程池的线程数量给太少的话你会发现执行的很慢）ExecutorService threadPool = Executors.newFixedThreadPool(300);
    finalCountDownLatch countDownLatch = newCountDownLatch(threadCount);
    for(inti = 0; i < threadCount; i++) {
      finalintthreadnum = i;
      threadPool.execute(() -> {// Lambda 表达式的运用try{
          test(threadnum);
        } catch(InterruptedException e) {
          // TODO Auto-generated catch blocke.printStackTrace();
        } finally{
          countDownLatch.countDown();// 表示一个请求已经被完成}

      });
    }
    countDownLatch.await();
    threadPool.shutdown();
    System.out.println("finish");
  }

  publicstaticvoidtest(intthreadnum)throwsInterruptedException {
    Thread.sleep(1000);// 模拟请求的耗时操作System.out.println("threadnum:"+ threadnum);
    Thread.sleep(1000);// 模拟请求的耗时操作}
}

上面的代码中，我们定义了请求的数量为550，当这550个请求被处理完成之后，才会执行System.out.println("finish");。

与CountDownLatch的第一次交互是主线程等待其他线程。主线程必须在启动其他线程后立即调用CountDownLatch.await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。

其他N个线程必须引用闭锁对象，因为他们需要通知CountDownLatch对象，他们已经完成了各自的任务。这种通知机制是通过 CountDownLatch.countDown()方法来完成的；每调用一次这个方法，在构造函数中初始化的count值就减1。所以当N个线程都调 用了这个方法，count的值等于0，然后主线程就能通过await()方法，恢复执行自己的任务。

CountDownLatch 的不足

CountDownLatch是一次性的，计数器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当CountDownLatch使用完毕后，它不能再次被使用。

CyclicBarrier(循环栅栏)

CyclicBarrier 和 CountDownLatch 非常类似，它也可以实现线程间的技术等待，但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。

CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是 CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。

CyclicBarrier 的应用场景

CyclicBarrier 可以用于多线程计算数据，最后合并计算结果的应用场景。比如我们用一个Excel保存了用户所有银行流水，每个Sheet保存一个帐户近一年的每笔银行流水，现在需要统计用户的日均银行流水，先用多线程处理每个sheet里的银行流水，都执行完之后，得到每个sheet的日均银行流水，最后，再用barrierAction用这些线程的计算结果，计算出整个Excel的日均银行流水。

CyclicBarrier 的使用示例

示例1：

/**
 * 
 * @authorSnailclimb
 * @date2018年10月1日* @Description: 测试CyclicBarrier 类中带参数的await() 方法*/publicclassCyclicBarrierExample2{
  // 请求的数量privatestaticfinalintthreadCount = 550;
  // 需要同步的线程数量privatestaticfinalCyclicBarrier cyclicBarrier = newCyclicBarrier(5);

  publicstaticvoidmain(String[] args)throwsInterruptedException {
    // 创建线程池ExecutorService threadPool = Executors.newFixedThreadPool(10);

    for(inti = 0; i < threadCount; i++) {
      finalintthreadNum = i;
      Thread.sleep(1000);
      threadPool.execute(() -> {
        try{
          test(threadNum);
        } catch(InterruptedException e) {
          // TODO Auto-generated catch blocke.printStackTrace();
        } catch(BrokenBarrierException e) {
          // TODO Auto-generated catch blocke.printStackTrace();
        }
      });
    }
    threadPool.shutdown();
  }

  publicstaticvoidtest(intthreadnum)throwsInterruptedException, BrokenBarrierException {
    System.out.println("threadnum:"+ threadnum + "is ready");
    try{
      /**等待60秒，保证子线程完全执行结束*/cyclicBarrier.await(60, TimeUnit.SECONDS);
    } catch(Exception e) {
      System.out.println("-----CyclicBarrierException------");
    }
    System.out.println("threadnum:"+ threadnum + "is finish");
  }

}

运行结果，如下：

threadnum:0isready
threadnum:1isready
threadnum:2isready
threadnum:3isready
threadnum:4isready
threadnum:4isfinishthreadnum:0isfinishthreadnum:1isfinishthreadnum:2isfinishthreadnum:3isfinishthreadnum:5isready
threadnum:6isready
threadnum:7isready
threadnum:8isready
threadnum:9isready
threadnum:9isfinishthreadnum:5isfinishthreadnum:8isfinishthreadnum:7isfinishthreadnum:6isfinish......

可以看到当线程数量也就是请求数量达到我们定义的 5 个的时候， await方法之后的方法才被执行。

另外，CyclicBarrier还提供一个更高级的构造函数CyclicBarrier(int parties, Runnable barrierAction)，用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景。示例代码如下：

/**
 * 
 * @authorSnailClimb
 * @date2018年10月1日* @Description: 新建CyclicBarrier 的时候指定一个Runnable
 */publicclassCyclicBarrierExample3{
  // 请求的数量privatestaticfinalintthreadCount = 550;
  // 需要同步的线程数量privatestaticfinalCyclicBarrier cyclicBarrier = newCyclicBarrier(5, () -> {
    System.out.println("------当线程数达到之后，优先执行------");
  });

  publicstaticvoidmain(String[] args)throwsInterruptedException {
    // 创建线程池ExecutorService threadPool = Executors.newFixedThreadPool(10);

    for(inti = 0; i < threadCount; i++) {
      finalintthreadNum = i;
      Thread.sleep(1000);
      threadPool.execute(() -> {
        try{
          test(threadNum);
        } catch(InterruptedException e) {
          // TODO Auto-generated catch blocke.printStackTrace();
        } catch(BrokenBarrierException e) {
          // TODO Auto-generated catch blocke.printStackTrace();
        }
      });
    }
    threadPool.shutdown();
  }

  publicstaticvoidtest(intthreadnum)throwsInterruptedException, BrokenBarrierException {
    System.out.println("threadnum:"+ threadnum + "is ready");
    cyclicBarrier.await();
    System.out.println("threadnum:"+ threadnum + "is finish");
  }

}

运行结果，如下：

threadnum:0isready
threadnum:1isready
threadnum:2isready
threadnum:3isready
threadnum:4isready
------当线程数达到之后，优先执行------
threadnum:4isfinishthreadnum:0isfinishthreadnum:2isfinishthreadnum:1isfinishthreadnum:3isfinishthreadnum:5isready
threadnum:6isready
threadnum:7isready
threadnum:8isready
threadnum:9isready
------当线程数达到之后，优先执行------
threadnum:9isfinishthreadnum:5isfinishthreadnum:6isfinishthreadnum:8isfinishthreadnum:7isfinish......

5.3 CyclicBarrier和CountDownLatch的区别

CountDownLatch是计数器，只能使用一次，而CyclicBarrier的计数器提供reset功能，可以多次使用。但是我不那么认为它们之间的区别仅仅就是这么简单的一点。我们来从jdk作者设计的目的来看，javadoc是这么描述它们的：

CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.(CountDownLatch: 一个或者多个线程，等待其他多个线程完成某件事情之后才能执行；) CyclicBarrier : A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.(CyclicBarrier : 多个线程互相等待，直到到达同一个同步点，再继续一起执行。)

对于CountDownLatch来说，重点是“一个线程（多个线程）等待”，而其他的N个线程在完成“某件事情”之后，可以终止，也可以等待。而对于CyclicBarrier，重点是多个线程，在任意一个线程没有完成，所有的线程都必须等待。

CountDownLatch是计数器，线程完成一个记录一个，只不过计数不是递增而是递减，而CyclicBarrier更像是一个阀门，需要所有线程都到达，阀门才能打开，然后继续执行。