JAVA线程池shutdown和shutdownNow的区别

比眉伴天荒 2022-09-25 14:22 164阅读 0赞

**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][http_xtu-xiaoxin.iteye.com_admin_blogs_647744]  
  
废话少说，要查看源码，首先进入ThreadPoolExecutor的shutDown()方法:

Java代码 [![收藏代码][icon_star.png]][icon_star.png 1]

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代码 [![收藏代码][icon_star.png]][icon_star.png 1]

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代码 [![收藏代码][icon_star.png]][icon_star.png 1]

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();”即可。  
还是那句话，希望对需要了解的人有点帮助。

转自：[/images/20220717/b1697642f5214b61b04e76ffc2e360dc.png][icon_star.png 1]

[http_xtu-xiaoxin.iteye.com_admin_blogs_647744]: http://xtu-xiaoxin.iteye.com/admin/blogs/647744
[icon_star.png]: http://www.iteye.com/images/icon_star.png
[icon_star.png 1]: /images/20220717/b1697642f5214b61b04e76ffc2e360dc.png