11、CountDownLatch

java.util.concurrent

Class CountDownLath

 

使一个线程或多个线程等待另外一个线程或多个线程操作的完成。

 

CountDownLath以一个给定的数字初始化。await方法一直阻塞直到当前这个数字由于其他线程运行countDown方法将初始化的数字减为0，阻塞等待的线程才能被唤醒执行。

这是一个一次性的现象，这个数字不能够重置。如果需要一个重复利用的版本，应该考虑使用CyclicBarrier。

 

一个CountDownLatch被初始化N，那么就会使得线程在await那里全部阻塞，直到有N个线程运行了CountDownLatch使得N变成了0，这时候阻塞的线程能够被唤醒执行。

 class Driver { 
           void main() throws InterruptedException {
             CountDownLatch startSignal = new CountDownLatch(1);
             CountDownLatch doneSignal = new CountDownLatch(N);

             for (int i = 0; i < N; ++i) // 创建和启动线程
               new Thread(new Worker(startSignal, doneSignal)).start();

             doSomethingElse();            
             startSignal.countDown();      // 让所有的线程处理12              doneSignal.await();           // 等待所有的线程完成
                doSomethingOther()

           }
 }


 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() { ... }
 }
         

程序分析：

上面的程序是一个驱动程序的框架。假设是这么一个流程：驱动刚开始要获得某些资源(doSomethingElse)；然后进行一些异步的初始化工作(doWork);最后为最终运行的软件做一些准备(doSomethingOther)。

这三个步骤是同步的。第二个步骤为了提高效率可以用多个线程去进行。有三个步骤，三个步骤要同步，于是有两个同步点。第一个同步点就是要在第一个步骤完成之后，第一个步骤只有一个线程完成，因此设置了

startSingal；第二个同步点在第二个步骤之后，这个步骤的完成需要N个线程，因此设置了doneSingal。

三个步骤在同一个main线程中，虽然第二个步骤可能起步比较早(产生N个线程准备去进行一些初始化工作)，但是他们都会阻塞在在一个同步点处，也就是startSingal.await处。当doSomethingElse方法完成之后，调用了

startSingal.countDown方法，此时startSingal的数字被减为0(也表示第一个阶段已经完成)，于是N个阻塞与第一个同步点的线程都被唤醒去执行异步初始化工作(doWork)。当然这些初始化工作的时长又长又短，但是

先被执行完的会阻塞于第二个同步点downSingal.await。直到N个线程完成了(doWork)，就会执行最后一个步骤。

 

 class Driver2 { 
               void main() throws InterruptedException {
                 CountDownLatch doneSignal = new CountDownLatch(N);
                 Executor e = ...

                 for (int i = 0; i < N; ++i) 
                   e.execute(new WorkerRunnable(doneSignal, i));

                 doneSignal.await();        
               }
             }

             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() { ... }
             }

程序分析：

上面这个程序框架就是一个典型算法“动态规划”的代码框架。它将问题分解成N个子问题，然后每一部分就是一个Runnable任务并且执行完一个任务就会使得数字减一，我们可以

将所有的任务以队列的形式组织到Executor当中。直到所有的子问题全部完成，协调线程会一直处于阻塞状态。