CountDownLatch 使用方法和场景

CountDownLatch is a versatile（通用的） synchronization tool and can be used for a number of purposes.
计数器为1，使多个等待线程同时开始运行；计数器为n，使线程等待n个线程全部结束后再运行

以下部分来自jdk注释
示例：

• The first is a start signal that prevents any worker from proceeding * until the driver is ready for them to proceed;
• The second is a completion signal that allows the driver to wait until all workers have completed. * * *

   {@code
   * class Driver { // ...
   *   void main() throws InterruptedException {
   *     CountDownLatch startSignal = new CountDownLatch(1);
   *     CountDownLatch doneSignal = new CountDownLatch(N);
   *
   *     for (int i = 0; i < N; ++i) // create and start threads
   *       new Thread(new Worker(startSignal, doneSignal)).start();
   *
   *     doSomethingElse();            // don't let run yet
   *     startSignal.countDown();      // let all threads proceed
   *     doSomethingElse();
   *     doneSignal.await();           // wait for all to finish
   *   }
   * }
   *
   * class Worker implements Runnable {
   *   private final CountDownLatch startSignal;
   *   private final CountDownLatch doneSignal;
   *   Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
   *     this.startSignal = startSignal;
   *     this.doneSignal = doneSignal;
   *   }
   *   public void run() {
   *     try {
   *       startSignal.await();
   *       doWork();
   *       doneSignal.countDown();
   *     } catch (InterruptedException ex) {} // return;
   *   }
   *
   *   void doWork() { ... }
   * }}

  * *

  Another typical usage would be to divide a problem into N parts, * describe each part with a Runnable that executes that portion and * counts down on the latch, and queue all the Runnables to an * Executor. When all sub-parts are complete, the coordinating thread * will be able to pass through await. (When threads must repeatedly * count down in this way, instead use a {@link CyclicBarrier}.) * *

   {@code
   * class Driver2 { // ...
   *   void main() throws InterruptedException {
   *     CountDownLatch doneSignal = new CountDownLatch(N);
   *     Executor e = ...
   *
   *     for (int i = 0; i < N; ++i) // create and start threads
   *       e.execute(new WorkerRunnable(doneSignal, i));
   *
   *     doneSignal.await();           // wait for all to finish
   *   }
   * }
   *
   * class WorkerRunnable implements Runnable {
   *   private final CountDownLatch doneSignal;
   *   private final int i;
   *   WorkerRunnable(CountDownLatch doneSignal, int i) {
   *     this.doneSignal = doneSignal;
   *     this.i = i;
   *   }
   *   public void run() {
   *     try {
   *       doWork(i);
   *       doneSignal.countDown();
   *     } catch (InterruptedException ex) {} // return;
   *   }
   *
   *   void doWork() { ... }
   * }}