码上快乐

相关内容   简体   繁体

主线程等待线程池所有任务完成(慢慢更新)

本文转载自  查看原文  2016-12-06 11:38  3275    JAVA/ CountDownLatch/ shutDown

一、CountDownLatch

public class CountDownLatchDemo {  

     final  static  SimpleDateFormat sdf= new  SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );  
     public  static  void  main(String[] args)  throws  InterruptedException {  
         CountDownLatch latch= new  CountDownLatch( 2 ); //两个工人的协作  
         Worker worker1= new  Worker( "zhang san" ,  5000 , latch);  
         Worker worker2= new  Worker( "li si" ,  8000 , latch);  
         worker1.start(); //  
         worker2.start(); //  
         latch.await(); //等待所有工人完成工作  
         System.out.println( "all work done at " +sdf.format( new  Date()));  
     }  
       
       
     static  class  Worker  extends  Thread{  
         String workerName;   
         int  workTime;  
         CountDownLatch latch;  
         public  Worker(String workerName , int  workTime ,CountDownLatch latch){  
              this .workerName=workerName;  
              this .workTime=workTime;  
              this .latch=latch;  
         }  
         public  void  run(){  
             System.out.println( "Worker " +workerName+ " do work begin at " +sdf.format( new  Date()));  
             doWork(); //工作了  
             System.out.println( "Worker " +workerName+ " do work complete at " +sdf.format( new  Date()));  
             latch.countDown(); //工人完成工作，计数器减一  
   
         }  
           
         private  void  doWork(){  
             try  {  
                 Thread.sleep(workTime);  
             }  catch  (InterruptedException e) {  
                 e.printStackTrace();  
             }  
         }  
     }  
       
        
}
 
二、主线程等待线程池所有任务完成

http://blog.chenlb.com/2008/12/main-thread-wait-all-sub-thread-finish-task-in-thread-pool.html

 

 

原文出处：http://blog.chenlb.com/2008/12/main-thread-wait-all-sub-thread-finish-task-in-thread-pool.html

用线程池编写多线程程序时，当所有任务完成时，要做一些统计的工作。而统计工作必须要在所有任务完成才能做。所以要让主线程等待所有任务完成。可以使用ThreadPoolExecutor.awaitTermination(long timeout, TimeUnit unit)。请看示例代码：

 
  1. package com.chenlb;  
  2.   
  3. import java.util.Random;  
  4. import java.util.concurrent.LinkedBlockingQueue;  
  5. import java.util.concurrent.ThreadPoolExecutor;  
  6. import java.util.concurrent.TimeUnit;  
  7.   
  8. /** 
  9.  * 线程池使用示例, 主线程等待所有任务完成再结束. 
  10.  * 
  11.  * @author chenlb 2008-12-2 上午10:31:03 
  12.  */  
  13. public class ThreadPoolUse {  
  14.   
  15.     public static class MyTask implements Runnable {  
  16.         private static int id = 0;  
  17.   
  18.         private String name = "task-"+(++id);  
  19.         private int sleep;   
  20.   
  21.         public MyTask(int sleep) {  
  22.             super();  
  23.             this.sleep = sleep;  
  24.         }  
  25.   
  26.         public void run() {  
  27.             System.out.println(name+" -----start-----");  
  28.             try {  
  29.                 Thread.sleep(sleep);    //模拟任务执行.  
  30.             } catch (InterruptedException e) {  
  31.                 e.printStackTrace();  
  32.             }  
  33.             System.out.println(name+" -----end "+sleep+"-----");  
  34.         }  
  35.   
  36.     }  
  37.   
  38.     public static void main(String[] args) {  
  39.         System.out.println("==================start==================");  
  40.         ThreadPoolExecutor executor = new ThreadPoolExecutor(5,5, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());  
  41.         int n = 10;  
  42.         int sleep = 10 * 1000;  //10s  
  43.         Random rm = new Random();  
  44.         for(int i=0; i<n; i++) {  
  45.             executor.execute(new MyTask(rm.nextInt(sleep)+1));  
  46.         }  
  47.   
  48.         executor.shutdown();//只是不能再提交新任务，等待执行的任务不受影响  
  49.   
  50.         try {  
  51.             boolean loop = true;  
  52.             do {    //等待所有任务完成  
  53.                 loop = !executor.awaitTermination(2, TimeUnit.SECONDS);  //阻塞，直到线程池里所有任务结束
  54.             } while(loop);  
  55.         } catch (InterruptedException e) {  
  56.             e.printStackTrace();  
  57.         }  
  58.   
  59.         System.out.println("==================end====================");  
  60.     }  
  61.   
  62. }  

当然还有其它方法。

 

http://xtu-xiaoxin.iteye.com/blog/649677

 

shutDown() 

    当线程池调用该方法时,线程池的状态则立刻变成SHUTDOWN状态。此时，则不能再往线程池中添加任何任务，否则将会抛出RejectedExecutionException异常。但是，此时线程池不会立刻退出，直到添加到线程池中的任务都已经处理完成，才会退出。 唯一的影响就是不能再提交任务了，正则执行的任务即使在阻塞着也不会结束，在排队的任务也不会取消。

shutdownNow() 

     根据JDK文档描述，大致意思是：执行该方法，线程池的状态立刻变成STOP状态，并试图停止所有正在执行的线程，不再处理还在池队列中等待的任务，当然，它会返回那些未执行的任务。 
     它试图终止线程的方法是通过调用Thread.interrupt()方法来实现的，但是大家知道，这种方法的作用有限，如果线程中没有sleep 、wait、Condition、定时锁等应用, interrupt()方法是无法中断当前的线程的。所以，ShutdownNow()并不代表线程池就一定立即就能退出，它可能必须要等待所有正在执行的任务都执行完成了才能退出。 

    上面对shutDown()以及shutDownNow()作了一个简单的、理论上的分析。如果想知道why,则需要亲自打开JDK源码，分析分析。 
      想要分析shutDown()以及shutDownNow()源码，我建议首先要对ThreadPoolExecutor有个大概了解。因为关闭线程池的所有方法逻辑都在ThreadPoolExecutor中处理的。 
      如果你真的想知道为什么，建议看一下我以前写的一篇对ThreadPoolExecutor源码分析的博文，我想这对你比较透彻的了解shutDown()和shutDownNow()的区别以及Java 线程池原理有很大的帮助。博文URL： 
         http://xtu-xiaoxin.iteye.com/admin/blogs/647744 

     废话少说，要查看源码，首先进入ThreadPoolExecutor的shutDown()方法: 

  

Java代码   收藏代码
  1. public void shutdown() {  
  2.      SecurityManager security = System.getSecurityManager();  
  3.     if (security != null)  
  4.             security.checkPermission(shutdownPerm);  
  5.         final ReentrantLock mainLock = this.mainLock;  
  6.         mainLock.lock();  
  7.         try {  
  8.             if (security != null) { // Check if caller can modify our threads  
  9.                 for (Worker w : workers)  
  10.                     security.checkAccess(w.thread);  
  11.             }  
  12.             int state = runState;  
  13.             if (state < SHUTDOWN)  
  14.                 //设置线程池状态为关闭状态  
  15.                 runState = SHUTDOWN;     //----------------代码1  
  16.             try {  
  17.                 for (Worker w : workers) {  
  18.                     //一个一个中断线程  
  19.                     w.interruptIfIdle();  //-----------------代码2  
  20.                 }  
  21.             } catch (SecurityException se) { // Try to back out  
  22.                 runState = state;  
  23.                 // tryTerminate() here would be a no-op  
  24.                 throw se;  
  25.             }  
  26.             tryTerminate(); // Terminate now if pool and queue empty  
  27.         } finally {  
  28.             mainLock.unlock();  
  29.         }  
  30.     }  


  看上面源码，代码1是线程池关闭的关键，如果线程池状态一旦设为SHUTDOWN，则在线程池中会出现两种现象： 
     1.你不能再往线程池中添加任何任务，否则会抛RejectedExecutionException异常(详细请看ThreadPoolExecutor的addIfUnderCorePoolSize方法)。 
     2.工作线程Worker获得池队列中的任务时(详细看Worker中的getTask()方法)的处理逻辑也发生了变化：如果线程池为RUNNING状态，并且池队列中没任务时，它会一直等待，直到你提交任务到池队列中，然后取出任务，返回。但是，一旦你执行了shutDown()方法,线程池状态为SHUTDOWN状态，它将不再等待了，直接返回null。如果返回null，则工作线程没有要执行的任务，直接退出(详细看Worker中run()方法)。 

    代码2是针对这种情况的：在线程池关闭前，有部分工作线程就一直在等着要处理的任务，也就是说工作线程空闲着(这种情况我描述的不好,其实就是Worker正在执行getTask()方法中’ r = workQueue.take();’代码段)。这时，调用interrupt()方法来中断这些Worker线程。进入代码2看看吧：。 
   
 
Java代码   收藏代码
  1. void interruptIfIdle() {  
  2.             final ReentrantLock runLock = this.runLock;  
  3.             /* 
  4.              * 注意这个条件，摆明的就是要等Worker中runTask()方法运行完后才成立。 
  5.              * 锁机制 
  6.              */  
  7.             if (runLock.tryLock()) {  
  8.                 try {  
  9.             /* 
  10.              * 如果当前工作线程没有正在运行，则中断线程 
  11.              * 他能中断工作线程的原因是getTask()方法能抛出一个 
  12.              * InterruptedException。这时，则可终止那些正在执行 
  13.              * workQueue.take()方法的工作线程 
  14.              */  
  15.             if (thread != Thread.currentThread())  
  16.             thread.interrupt();           
  17.                 } finally {  
  18.                     runLock.unlock();  
  19.                 }  
  20.             }  
  21.         }  


   最后进入shutDownNow()方法看看，这个更简单了，就是设置线程池状态为STOP，然后依次调用工作线程的interrupt()方法，就这么简单，最后还是把源码贴出来吧： 
    
     
Java代码   收藏代码
  1. public List<Runnable> shutdownNow() {  
  2.        /* 
  3.         * shutdownNow differs from shutdown only in that 
  4.         * 1. runState is set to STOP, 
  5.         * 2. all worker threads are interrupted, not just the idle ones, and 
  6.         * 3. the queue is drained and returned. 
  7.         */  
  8. SecurityManager security = System.getSecurityManager();  
  9. if (security != null)  
  10.            security.checkPermission(shutdownPerm);  
  11.   
  12.        final ReentrantLock mainLock = this.mainLock;  
  13.        mainLock.lock();  
  14.        try {  
  15.            if (security != null) { // Check if caller can modify our threads  
  16.                for (Worker w : workers)  
  17.                    security.checkAccess(w.thread);  
  18.            }  
  19.   
  20.            int state = runState;  
  21.            if (state < STOP)  
  22.                runState = STOP;  
  23.   
  24.            try {  
  25.                for (Worker w : workers) {  
  26.                    w.interruptNow();  
  27.                }  
  28.            } catch (SecurityException se) { // Try to back out  
  29.                runState = state;  
  30.                // tryTerminate() here would be a no-op  
  31.                throw se;  
  32.            }  
  33.   
  34.            List<Runnable> tasks = drainQueue();  
  35.            tryTerminate(); // Terminate now if pool and queue empty  
  36.            return tasks;  
  37.        } finally {  
  38.            mainLock.unlock();  
  39.        }  
  40.    }  

    上面代码没什么好分析的了，一看就明白，其实别看上面代码一大篇，我们只关心“w.interruptNow();”即可。 
 
 
 


免责声明！

本站转载的文章为个人学习借鉴使用，本站对版权不负任何法律责任。如果侵犯了您的隐私权益，请联系本站邮箱yoyou2525@163.com删除。



猜您在找 主线程等待所有子线程执行完成之后再继续往下执行的解决方案 Java线程池如何优雅地等待所有任务执行完 线程池： 等待线程池内所有线程执行完毕后再继续任务 java中主线程等待所有子线程结束 如何让主线程等待所有子线程执行完毕 c# Task多线程并行任务中等待所有线程都执行完成 CompletableFuture实现异步获取结果并且等待所有异步任务完成 CompletableFuture实现异步获取结果并且等待所有异步任务完成 Java主线程等待所有子线程执行完毕再执行解决办法（转） 线程池如何等待所有线程执行结束
 
粤ICP备18138465号  © 2018-2025 CODEPRJ.COM