注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

Fly to the Sky!

很多人因为寂寞而错爱一个人,更多人因为错爱一个人而寂寞一生。

 
 
 

日志

 
 

【转】CountDownLatch join 或 CountDownLatch 让主线程等待所有子线程完成  

2010-07-13 17:23:01|  分类: 默认分类 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |
2008-12-28
原文地址:http://vvggsky.javaeye.com/blog/306066
关键字: countdownlatch
用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法,所以在当前计数到达零之前,await 方法会一直受阻塞。之后,会释放所有等待的线程,await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数,请考虑使用 CyclicBarrier。

CountDownLatch 是一个通用同步工具,它有很多用途。将计数 1 初始化的 CountDownLatch 用作一个简单的开/关锁存器,或入口:在通过调用 countDown() 的线程打开入口前,所有调用 await 的线程都一直在入口处等待。用 N 初始化的 CountDownLatch 可以使一个线程在 N 个线程完成某项操作之前一直等待,或者使其在某项操作完成 N 次之前一直等待。

CountDownLatch 的一个有用特性是,它不要求调用 countDown 方法的线程等到计数到达零时才继续,而在所有线程都能通过之前,它只是阻止任何线程继续通过一个 await。

示例用法: 下面给出了两个类,其中一组 worker 线程使用了两个倒计数锁存器:

第一个类是一个启动信号,在 driver 为继续执行 worker 做好准备之前,它会阻止所有的 worker 继续执行。
第二个类是一个完成信号,它允许 driver 在完成所有 worker 之前一直等待。
Java 代码
  1. class Driver { // ...  
  2.    void main() throws InterruptedException {  
  3.      CountDownLatch startSignal = new CountDownLatch(1);  
  4.      CountDownLatch doneSignal = new CountDownLatch(N);  
  5.   
  6.      for (int i = 0; i < N; ++i) // create and start threads  
  7.        new Thread(new Worker(startSignal, doneSignal)).start();  
  8.   
  9.      doSomethingElse();            // don't let run yet  
  10.      startSignal.countDown();      // let all threads proceed  
  11.      doSomethingElse();  
  12.      doneSignal.await();           // wait for all to finish  
  13.    }  
  14.  }  
  15.   
  16.  class Worker implements Runnable {  
  17.    private final CountDownLatch startSignal;  
  18.    private final CountDownLatch doneSignal;  
  19.    Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {  
  20.       this.startSignal = startSignal;  
  21.       this.doneSignal = doneSignal;  
  22.    }  
  23.    public void run() {  
  24.       try {  
  25.         startSignal.await();  
  26.         doWork();  
  27.         doneSignal.countDown();  
  28. catch (InterruptedException ex) {} // return;  
  29.    }  
  30.   
  31.    void doWork() { ... }  
  32.  }  
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 个部分,用执行每个部分并让锁存器倒计数的 Runnable 来描述每个部分,然后将所有 Runnable 加入到 Executor 队列。当所有的子部分完成后,协调线程就能够通过 await。(当线程必须用这种方法反复倒计数时,可改为使用 CyclicBarrier。)
Java 代码
  1. class Driver2 { // ...  
  2.   void main() throws InterruptedException {  
  3.     CountDownLatch doneSignal = new CountDownLatch(N);  
  4.     Executor e = ...  
  5.   
  6.     for (int i = 0; i < N; ++i) // create and start threads  
  7.       e.execute(new WorkerRunnable(doneSignal, i));  
  8.   
  9.     doneSignal.await();           // wait for all to finish  
  10.   }  
  11. }  
  12.   
  13. class WorkerRunnable implements Runnable {  
  14.   private final CountDownLatch doneSignal;  
  15.   private final int i;  
  16.   WorkerRunnable(CountDownLatch doneSignal, int i) {  
  17.      this.doneSignal = doneSignal;  
  18.      this.i = i;  
  19.   }  
  20.   public void run() {  
  21.      try {  
  22.        doWork(i);  
  23.        doneSignal.countDown();  
  24.      } catch (InterruptedException ex) {} // return;  
  25.   }  
  26.   
  27.   void doWork() { ... }  
  28. }  
 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() { ... }
 }


Java 代码
  1. public class WaitAllSubThread {     
  2.     
  3.     /*int liveThreadNum;//记录运行的子线程数   
  4.     */    
  5.     int n;  //工作线 程数     
  6.     
  7.     public WaitAllSubThread(int n) {     
  8.         this.n = n;     
  9.     }     
  10.     
  11.     class Worker implements Runnable {     
  12.     
  13.         String name;     
  14.         int sleep;     
  15.     
  16.         public Worker(String name, int sleep) {     
  17.             this.name = name;     
  18.             this.sleep = sleep;     
  19.         }     
  20.     
  21.         public void run() {     
  22.             /*upLive(); //计算此线程已经工作.   
  23.             */    
  24.             System.out.println(name+", start to work.");     
  25.             try {     
  26.                 Thread.sleep(sleep);    //虚拟工作. 10s 随机时间     
  27.             } catch (InterruptedException e) {     
  28.                 System.out.println(name+" interrupted.");     
  29.             }     
  30.             System.out.println(name+", end to work ["+sleep+"] sleep.");     
  31.             /*downLive();   //此线程工作完成   
  32.             */    
  33.         }     
  34.     }     
  35. /*  //记录线程数的同步方法.   
  36.     private synchronized void downLive() {   
  37.         liveThreadNum--;   
  38.     }   
  39.   
  40.     private synchronized void upLive() {   
  41.         liveThreadNum++;   
  42.     }   
  43.   
  44.     private synchronized boolean isLive() {   
  45.         return liveThreadNum > 0;   
  46.     }*/    
  47.     
  48.     public void run() {     
  49.         System.out.println("-------------main run start-------------");     
  50.         int sleepSaid = 10 * 1000;  //每个工作线程虚拟工作最大时间     
  51.         Random rm = new Random();     
  52.         for(int i=0; i<ths.length; i++) {     
  53.             ths[i] = new Thread(new MyTask(rm.nextInt(sleep)+1));     
  54.     
  55.             ths[i].start();     
  56.         }     
  57.     
  58.         for(Thread th : ths) {     
  59.             try {     
  60.                 th.join();//join方式     
  61.             } catch (InterruptedException e) {     
  62.                 // TODO Auto-generated catch block     
  63.                 e.printStackTrace();     
  64.             }     
  65.         }     
  66.         /*//等待所有工作线程完成.   
  67.         while(isLive()) {   
  68.             try {   
  69.                 Thread.sleep(1000); //每隔1s查看下是否所有线程完成.   
  70.             } catch (InterruptedException e) {   
  71.                 System.out.println("main thread sleep interrupted.");   
  72.             }   
  73.         }*/    
  74.         System.out.println("---------------main run end--------------");     
  75.     }     
  76.     
  77.     public static void main(String[] args) {     
  78.         WaitAllSubThread wast = new WaitAllSubThread(10);     
  79.         wast.run();     
  80.     }     
  81. }    
public class WaitAllSubThread {   
  
    /*int liveThreadNum;//记录运行的子线程数  
    */  
    int n;  //工作线程数   
  
    public WaitAllSubThread(int n) {   
        this.n = n;   
    }   
  
    class Worker implements Runnable {   
  
        String name;   
        int sleep;   
  
        public Worker(String name, int sleep) {   
            this.name = name;   
            this.sleep = sleep;   
        }   
  
        public void run() {   
            /*upLive(); //计算此线程已经工作.  
            */  
            System.out.println(name+", start to work.");   
            try {   
                Thread.sleep(sleep);    //虚拟工作. 10s 随机时间   
            } catch (InterruptedException e) {   
                System.out.println(name+" interrupted.");   
            }   
            System.out.println(name+", end to work ["+sleep+"] sleep.");   
            /*downLive();   //此线程工作完成  
            */  
        }   
    }   
/*  //记录线程数的同步方法.  
    private synchronized void downLive() {  
        liveThreadNum--;  
    }  
 
    private synchronized void upLive() {  
        liveThreadNum++;  
    }  
 
    private synchronized boolean isLive() {  
        return liveThreadNum > 0;  
    }*/  
  
    public void run() {   
        System.out.println("-------------main run start-------------");   
        int sleepSaid = 10 * 1000;  //每个工作线程虚拟工作最大时间   
        Random rm = new Random();   
        for(int i=0; i<ths.length; i++) {   
            ths[i] = new Thread(new MyTask(rm.nextInt(sleep)+1));   
  
            ths[i].start();   
        }   
  
        for(Thread th : ths) {   
            try {   
                th.join();//join方式   
            } catch (InterruptedException e) {   
                // TODO Auto-generated catch block   
                e.printStackTrace();   
            }   
        }   
        /*//等待所有工作线程完成.  
        while(isLive()) {  
            try {  
                Thread.sleep(1000); //每隔1s查看下是否所有线程完成.  
            } catch (InterruptedException e) {  
                System.out.println("main thread sleep interrupted.");  
            }  
        }*/  
        System.out.println("---------------main run end--------------");   
    }   
  
    public static void main(String[] args) {   
        WaitAllSubThread wast = new WaitAllSubThread(10);   
        wast.run();   
    }   
}  


Java 代码
  1. public class CountDownLatchUse {     
  2.     
  3.     final CountDownLatch downLatch;     
  4.     int n;  //工作线 程数     
  5.     
  6.     public CountDownLatchUse(int n) {     
  7.         this.downLatch = new CountDownLatch(n);     
  8.         this.n = n;     
  9.     }     
  10.     
  11.     class Worker implements Runnable {     
  12.     
  13.         String name;     
  14.         int sleep;     
  15.     
  16.         public Worker(String name, int sleep) {     
  17.             this.name = name;     
  18.             this.sleep = sleep;     
  19.         }     
  20.     
  21.         public void run() {     
  22.             System.out.println(name+", start to work.");     
  23.             try {     
  24.                 Thread.sleep(sleep);    //虚拟工作. 10s 随机时间     
  25.             } catch (InterruptedException e) {     
  26.                 System.out.println(name+" interrupted.");     
  27.             }     
  28.             System.out.println(name+", end to work ["+sleep+"] sleep.");     
  29.             meDone();   //某个工作线程完成     
  30.         }     
  31.     }     
  32.     
  33.     private void meDone() {     
  34.         downLatch.countDown();     
  35.     }     
  36.     
  37.     public void run() {     
  38.         System.out.println("-------------main run start-------------");     
  39.         int sleepSaid = 10 * 1000;  //每个工作线程虚拟工作最大时间     
  40.         Random rm = new Random();     
  41.         for(int i=0; i<n; i++) {     
  42.             new Thread(new Worker("worker-"+i, rm.nextInt(sleepSaid)+1)).start();     
  43.         }     
  44.     
  45.         try {     
  46.             downLatch.await();  //等待所有工作线程完成.     
  47.         } catch (InterruptedException e) {     
  48.             System.out.println("main interrupted.");     
  49.         }     
  50.         System.out.println("---------------main run end--------------");     
  51.     }     
  52.     
  53.     public static void main(String[] args) {     
  54.         CountDownLatchUse mtu = new CountDownLatchUse(10);     
  55.         mtu.run();     
  56.     }     

  评论这张
 
阅读(935)| 评论(1)
推荐 转载

历史上的今天

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017