CountDownLatch|CyclicBarrier

        其实很早之前就有过这么个想法:比如有10个任务,其中有个任务A,A任务需要等待其他所有的任务完成后,再开始执行,这里每个任务都是在单独的线程完成,举个栗子:对Launcher类的App,需要对Android设备上的所有应用的入口信息处理,这个过程是相当长的,但是我们可以根据当前设备可用线程数,创建一定数量的线程,将入口处理分成多个任务单独处理,处理完后,一次性写入数据库.而写入出具库行为需要等待所有的图标处理完毕才执行,就是我刚才说的场景了,而CountDownLatch 正好可以满足这个场景的需要.

        CountDownLatch就字面意思就是 倒计数锁存器,他可以让线程在CountDownLatch.await()处等待,直到其他线程调用CountDownLatch.countDown()时才换线在CountDownLatch.await()处等待的线程,这里面还有一个重要的点:CountDownLatch.countDown()必须调用N次, N就是创建CountDownLatch 时由构造器指定的值N.

        这样的就可以达到这样的目的:①让某一个线程等待其他多个线程执行完毕后才开始执行②让多个线程等待某一个线程执行完毕后才开始执行.示例代码如下(官方代码):

1. 在Driver准备好之前,其他的Worker都要等待
2. 在其他Worker全部执行完之前,Driver等待

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

第二个用法就是将某个任务分成N个部分,然后执行,直到这N个任务完成后,主线程才会继续执行,与上面提到的2 描述很类似:

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

        CyclicBarrier 就是周期性的屏障,他允许一组线程互相等待,直到所有的线程都到达屏障点.在固定数目的线程中,让线程互相等待,这一点非常有用,同时CycliBarrier还支持一个可选的 Runnable,允许在屏障点到达的最后一个线程执行这个可选的Runnable,比如下面的代码(官方地址):

class Solver {
   final int N;
   final float[][] data;
   final CyclicBarrier barrier;

   class Worker implements Runnable {
     int myRow;
     Worker(int row) { myRow = row; }
     public void run() {
       while (!done()) {
         processRow(myRow);

         try {
           barrier.await();
         } catch (InterruptedException ex) {
           return;
         } catch (BrokenBarrierException ex) {
           return;
         }
       }
     }
   }

   public Solver(float[][] matrix) {
     data = matrix;
     N = matrix.length;
     Runnable barrierAction =
       new Runnable() { public void run() { mergeRows(...); }};
     barrier = new CyclicBarrier(N, barrierAction);

     List<Thread> threads = new ArrayList<>(N);
     for (int i = 0; i < N; i++) {
       Thread thread = new Thread(new Worker(i));
       threads.add(thread);
       thread.start();
     }

     // wait until done
     for (Thread thread : threads)
       thread.join();
   }
 }

其中,每个Work线程处理每一行的数据,注意,我们的 new CyclicBarrier(N,barrierAction),其中N就是屏障点到达的次数,当每个线程调用barrier.await()时,线程在此处等待,当最后一个线程调用barrier.await(),也就是第N次调用时,该线程立即返回,然后执行barrierAction,然后其他等待的线程被一次唤醒! 

如果barrierAction 不依赖于暂停的线程,也即等待最后一个线程调用barrier.await(),那么任何线程都可以在自己被恢复后执行barrierAction,为了实现这个目标,每个barrier.await()的调用都会返回到达线程的索引(也就是线程的等待索引,最后先等待的线程的barrier.await()返回是最大的(N -1),所以我们可以方便的选哪个线程来执行barrierAction!

关于更多CyclicBarrier 和CountDownLatch的详细信息,请见官网