现在的位置: 首页 > 综合 > 正文

主线程等待线程池所有任务完成

2018年12月10日 ⁄ 综合 ⁄ 共 6939字 ⁄ 字号 评论关闭

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,560, 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();”即可。 

抱歉!评论已关闭.