ExecutorService生命周期

最新推荐文章于 2024-09-11 10:00:26 发布
最新推荐文章于 2024-09-11 10:00:26 发布
阅读量1.3k 收藏
点赞数
分类专栏： Java

ExecutorService接口继承了Executor接口，定义了一些生命周期的方法

Java代码  复制代码  收藏代码
  1. public interface ExecutorService extends Executor {   
  2. void shutdown();   
  3. List<Runnable> shutdownNow();   
  4. boolean isShutdown();   
  5. boolean isTerminated();   
  6. boolean awaitTermination(long timeout, TimeUnit unit)   
  7.         throws InterruptedException;   
  8. }  
[java]  view plain copy
  1. public interface ExecutorService extends Executor {  
  2. void shutdown();  
  3. List<Runnable> shutdownNow();  
  4. boolean isShutdown();  
  5. boolean isTerminated();  
  6. boolean awaitTermination(long timeout, TimeUnit unit)  
  7.         throws InterruptedException;  
  8. }  

本文，我们逐一分析里面的每个方法。

 

首先，我们需要创建一个任务代码，这段任务代码主要是随机生成含有10个字符的字符串

Java代码  复制代码  收藏代码
  1. /**  
  2.  * 随机生成10个字符的字符串  
  3.  * @author dream-victor  
  4.  *  
  5.  */  
  6. public class Task1 implements Callable<String> {   
  7.   
  8.     @Override  
  9.     public String call() throws Exception {   
  10.         String base = "abcdefghijklmnopqrstuvwxyz0123456789";   
  11.         Random random = new Random();   
  12.         StringBuffer sb = new StringBuffer();   
  13.         for (int i = 0; i < 10; i++) {   
  14.             int number = random.nextInt(base.length());   
  15.             sb.append(base.charAt(number));   
  16.         }   
  17.         return sb.toString();   
  18.     }   
  19.   
  20. }  
[java]  view plain copy
  1. /** 
  2.  * 随机生成10个字符的字符串 
  3.  * @author dream-victor 
  4.  * 
  5.  */  
  6. public class Task1 implements Callable<String> {  
  7.   
  8.     @Override  
  9.     public String call() throws Exception {  
  10.         String base = "abcdefghijklmnopqrstuvwxyz0123456789";  
  11.         Random random = new Random();  
  12.         StringBuffer sb = new StringBuffer();  
  13.         for (int i = 0; i < 10; i++) {  
  14.             int number = random.nextInt(base.length());  
  15.             sb.append(base.charAt(number));  
  16.         }  
  17.         return sb.toString();  
  18.     }  
  19.   
  20. }  

 然后，我们还需要一个长任务，这里我们默认是沉睡10秒，

Java代码  复制代码  收藏代码
  1. /**  
  2.  * 长时间任务  
  3.  *   
  4.  * @author dream-victor  
  5.  *   
  6.  */  
  7. public class LongTask implements Callable<String> {   
  8.   
  9.     @Override  
  10.     public String call() throws Exception {   
  11.         TimeUnit.SECONDS.sleep(10);   
  12.         return "success";   
  13.     }   
  14.   
  15. }  
[java]  view plain copy
  1. /** 
  2.  * 长时间任务 
  3.  *  
  4.  * @author dream-victor 
  5.  *  
  6.  */  
  7. public class LongTask implements Callable<String> {  
  8.   
  9.     @Override  
  10.     public String call() throws Exception {  
  11.         TimeUnit.SECONDS.sleep(10);  
  12.         return "success";  
  13.     }  
  14.   
  15. }  

OK，所有前期准备完毕，下面我们就来分析一下ExecutorService接口中和生命周期有关的这些方法：

 

1、shutdown方法：这个方法会平滑地关闭ExecutorService，当我们调用这个方法时，ExecutorService停止接受任何新的任务且等待已经提交的任务执行完成(已经提交的任务会分两类：一类是已经在执行的，另一类是还没有开始执行的)，当所有已经提交的任务执行完毕后将会关闭ExecutorService。这里我们先不举例在下面举例。

 

2、awaitTermination方法：这个方法有两个参数，一个是timeout即超时时间，另一个是unit即时间单位。这个方法会使线程等待timeout时长，当超过timeout时间后，会监测ExecutorService是否已经关闭，若关闭则返回true，否则返回false。一般情况下会和shutdown方法组合使用。例如：

Java代码  复制代码  收藏代码
  1. ExecutorService service = Executors.newFixedThreadPool(4);   
  2. service.submit(new Task1());   
  3. service.submit(new Task1());   
  4. service.submit(new LongTask());   
  5. service.submit(new Task1());   
  6.   
  7. service.shutdown();   
  8.   
  9. while (!service.awaitTermination(1, TimeUnit.SECONDS)) {   
  10.     System.out.println("线程池没有关闭");   
  11. }   
  12. System.out.println("线程池已经关闭");  
[java]  view plain copy
  1. ExecutorService service = Executors.newFixedThreadPool(4);  
  2. service.submit(new Task1());  
  3. service.submit(new Task1());  
  4. service.submit(new LongTask());  
  5. service.submit(new Task1());  
  6.   
  7. service.shutdown();  
  8.   
  9. while (!service.awaitTermination(1, TimeUnit.SECONDS)) {  
  10.     System.out.println("线程池没有关闭");  
  11. }  
  12. System.out.println("线程池已经关闭");  

 这段代码中，我们在第三次提交了一个长任务，这个任务将执行10秒沉睡，紧跟着执行了一次shutdown()方法，假设：这时ExecutorService被立即关闭，下面调用service.awaitTermination(1, TimeUnit.SECONDS)方法时应该返回true，程序执行结果应该只会打印出：“线程池已经关闭”。但是，真实的运行结果如下：

Java代码  复制代码  收藏代码
  1. 线程池没有关闭   
  2. 线程池没有关闭   
  3. 线程池没有关闭   
  4. 线程池没有关闭   
  5. 线程池没有关闭   
  6. 线程池没有关闭   
  7. 线程池没有关闭   
  8. 线程池没有关闭   
  9. 线程池没有关闭   
  10. 线程池已经关闭  
[java]  view plain copy
  1. 线程池没有关闭  
  2. 线程池没有关闭  
  3. 线程池没有关闭  
  4. 线程池没有关闭  
  5. 线程池没有关闭  
  6. 线程池没有关闭  
  7. 线程池没有关闭  
  8. 线程池没有关闭  
  9. 线程池没有关闭  
  10. 线程池已经关闭  

 这说明我们假设错误，service.awaitTermination(1, TimeUnit.SECONDS)每隔一秒监测一次ExecutorService的关闭情况，而长任务正好需要执行10秒，因此会在前9秒监测时ExecutorService为未关闭状态，而在第10秒时已经关闭，因此第10秒时输出：线程池已经关闭。这也验证了shutdown方法关闭ExecutorService的条件。

 

3、shutdownNow方法：这个方法会强制关闭ExecutorService，它将取消所有运行中的任务和在工作队列中等待的任务，这个方法返回一个List列表，列表中返回的是等待在工作队列中的任务。例如：

Java代码  复制代码  收藏代码
  1. ExecutorService service = Executors.newFixedThreadPool(3);   
  2. service.submit(new LongTask());   
  3. service.submit(new LongTask());   
  4. service.submit(new LongTask());   
  5. service.submit(new LongTask());   
  6. service.submit(new LongTask());   
  7.   
  8. List<Runnable> runnables = service.shutdownNow();   
  9. System.out.println(runnables.size());   
  10.   
  11. while (!service.awaitTermination(1, TimeUnit.MILLISECONDS)) {   
  12.     System.out.println("线程池没有关闭");   
  13. }   
  14. System.out.println("线程池已经关闭");  
[java]  view plain copy
  1. ExecutorService service = Executors.newFixedThreadPool(3);  
  2. service.submit(new LongTask());  
  3. service.submit(new LongTask());  
  4. service.submit(new LongTask());  
  5. service.submit(new LongTask());  
  6. service.submit(new LongTask());  
  7.   
  8. List<Runnable> runnables = service.shutdownNow();  
  9. System.out.println(runnables.size());  
  10.   
  11. while (!service.awaitTermination(1, TimeUnit.MILLISECONDS)) {  
  12.     System.out.println("线程池没有关闭");  
  13. }  
  14. System.out.println("线程池已经关闭");  

 这段代码中，我们限制了线程池的长度是3，提交了5个任务，这样将有两个任务在工作队列中等待，当我们执行shutdownNow方法时，ExecutorService被立刻关闭，所以在service.awaitTermination(1, TimeUnit.MILLISECONDS)方法校验时返回的是false，因此没有输出：线程池没有关闭。而在调用shutdownNow方法时，我们接受到了一个List，这里包含的是在工作队列中等待执行的任务，由于线程池长度为3，且执行的都是长任务，所以当提交了三个任务后线程池已经满了，剩下的两次提交只能在工作队列中等待，因此我们看到runnables的大小为2，结果如下：

Java代码  复制代码  收藏代码
  1. 2  
  2. 线程池已经关闭  
[java]  view plain copy
  1. 2  
  2. 线程池已经关闭  
 

4、isTerminated方法：这个方法会校验ExecutorService当前的状态是否为“TERMINATED”即关闭状态，当为“TERMINATED”时返回true否则返回false。例如：

Java代码  复制代码  收藏代码
  1. ExecutorService service = Executors.newFixedThreadPool(3);   
  2. service.submit(new Task1());   
  3. service.submit(new Task1());   
  4. service.submit(new LongTask());   
  5.   
  6. service.shutdown();   
  7. System.out.println(System.currentTimeMillis());   
  8. while (!service.isTerminated()) {   
  9. }   
  10. System.out.println(System.currentTimeMillis());  
[java]  view plain copy
  1. ExecutorService service = Executors.newFixedThreadPool(3);  
  2. service.submit(new Task1());  
  3. service.submit(new Task1());  
  4. service.submit(new LongTask());  
  5.   
  6. service.shutdown();  
  7. System.out.println(System.currentTimeMillis());  
  8. while (!service.isTerminated()) {  
  9. }  
  10. System.out.println(System.currentTimeMillis());  

这段代码我们执行了两个正常的任务和一个长任务，然后调用了shutdown方法，我们知道调用shutdown方法并不会立即关闭ExecutorService，这时我们记录一下监测循环执行前的时间，在没有关闭前我们一直进入一个空循环中，直到 ExecutorService关闭后退出循环，这里我们知道长任务执行时间大约为10秒，我们看一下上述程序运行结果：

Java代码  复制代码  收藏代码
  1. 1303298818621  
  2. 1303298828634  
  3. 相差：10013毫秒，转换一下除以1000，得到相差大约10秒  
[java]  view plain copy
  1. 1303298818621  
  2. 1303298828634  
  3. 相差：10013毫秒，转换一下除以1000，得到相差大约10秒  

这10秒正好是长任务执行的时间，因此在 ExecutorService正常关闭后isTerminated方法返回true。

 

5、isShutdown方法：这个方法在ExecutorService关闭后返回true，否则返回false。方法比较简单不再举例。

以上讨论是基于ThreadPoolExecutor的实现，不同的实现会有所不同需注意。

张伟灿
关注
专栏目录
java 线程的生命周期详解
08-30
在实际编程中，我们还可以使用线程池来管理线程，比如`ExecutorService`，它可以帮助我们更好地控制线程的创建和销毁，减少线程生命周期的开销。此外，线程间的同步和通信机制，如`synchronized`关键字、`wait()`, `...
ExecutorService.shutdown()应该是在线程执行完毕后，才会去关闭
sjy_2010的专栏
04-29 2391
看到一个博客，如下 [url=http://bbs.csdn.net/topics/390268738]Java多线程-线程池ExecutorService.shutdown什么时候执行[/url] 其中问题： ExecutorService.shutdown()应该是在线程执行完毕后，才会去关闭。 但是我用了计数信号量Semaphore后，发现线程还没有跑完，他就执行了shutdow...
Java 中的 ExecutorService 与线程池管理
最新发布
qq_40697623的博客
09-11 961
是 Java 并发包 () 中的一个接口，主要用于管理线程池。与手动创建线程的方式不同，它将任务提交给线程池，并管理这些线程的生命周期。通过，我们可以轻松控制线程的创建、执行、关闭等操作。：提交任务给线程池执行，返回一个Future，代表任务的执行结果。shutdown()：有序关闭线程池，不再接受新的任务，但会完成已提交的任务。：立即关闭线程池，并尝试中断正在执行的任务。：执行多个任务，等待所有任务完成并返回结果。：执行多个任务，只要其中一个任务完成，就返回该任务的结果。通过。
Java多线程十问十答（三）
hanxiaozhang的博客
07-18 247
前言： 在这篇文章中，我将介绍一下线程池、Executor框架、ThreadLocal、CAS等相关知识，希望对大家的工作和学习有一定帮助！具体的内容如下： 正文： Q&A1：线程池（ThreadPoolExecutor）的工作流程是什么？ (1) 默认情况下，创建完线程池后并不会立即创建线程, 而是等到有任务提交时才会创建线程来进行处理。（除非调用prestartCoreThread或prestartAllCoreThreads方法） (2) 当线程数小于核心线程数时，每提交一个任...
线程池时候当程序结束时候记得调用shutdown关闭线程池
沮丧的南瓜
03-15 2116
一、使用线程池时候当程序结束时候记得调用shutdown关闭线程池 日常开发中为了便于线程的有效复用，线程池是经常会被用的工具，然而线程池使用完后如果不调用shutdown会导致线程池资源一直不会被释放。下面通过简单例子来说明该问题。 1、问题复现 下面通过一个例子说明当不调用线程池对象的shutdown方法后，当线程池里面的任务执行完毕后主线程这个JVM不会退出。 public class TestShutDown { static void asynExecuteOne() {
线程池程序不会结束与shutdown有关
palwang723的专栏
09-28 1091
使用线程池时，在main完成之前没的调用shutdonw使得，java进程不会结束。线程池默认的线程不是“守护线程”，线程池的timeout 大于 0时，code数量的线程是不会终止的。所以，当所有任务完成后，java程序不会结束。 ExecutorService.shutdown()将使之前通过Executor.execute()提交的任务运行结束后关闭线程池。Executor...
java ExecutorService使用方法详解
09-01
线程的生命周期由`ExecutorService`内部管理，如果线程完成了它的任务，`ExecutorService`会决定是否回收这个线程。 6. **线程的生命周期** 在`JobThread`的`run()`方法中，线程会持续运行，直到主线程将其从`...
线程的生命周期.pdf
09-30
Java线程的生命周期是编程中一个关键的概念，尤其是在多线程编程中。线程的生命周期主要包括以下几个阶段： 1. **创建**：线程的创建可以通过两种方式：直接实例化Thread类或者继承Thread类并重写run()方法。例如，...
Java线程生命周期.zip
03-18
Java线程生命周期是Java编程中的核心概念，它关乎程序的并发执行和性能优化。线程在Java中扮演着至关重要的角色，特别是在多任务处理和实时系统中。理解线程的生命周期有助于开发者更有效地管理和控制程序运行流程。...
Java 线程池ExecutorService详解及实例代码
09-01
线程池的主要目的是为了优化线程的生命周期管理。在处理大量并发任务时，如果每个任务都单独创建线程，那么频繁的线程创建和销毁会带来很大的性能开销。线程池可以预先创建一定数量的线程，待有任务提交时直接复用，...
Java多线程（Thread， Runnable，Callable， Executors）
weixin_43602614的博客
03-27 318
Java多线程实现方式有4种，继承Thread类，实现Runnable接口，实现Callable接口，使用线程池实现（Executors） 1. 继承Thread类 通过继承Thread类，实现run方法，从而实现多线程。该方式实现简单，但该类不可作为拓展类，因为Java是单继承模式，该类继承了Thread类，便无法继承其他类了。 class ChildThread2 extends Thread...
线程池,Executors,Callable,Lock,使用线程池,线程池的相关方法
W_a_n_g_c_h_i的博客
02-23 247
当 任 务 执 行 时 间 大 于 间 隔 时 间 ,下 一次 任 务 将 会 在 上 一 次 任 务 结束后 ,立 即 执 行。> task ):给线程池提交线程任务。下 一 次 任 务 开 始 时 间 -上 一 次 任 务 结束 时 间 =间 隔 时 间。> submit(Runnable task):给线程池提交线程任务。3,关 闭 线 程 池 ,注 意 抢 占 线 程 池 中 的 线 程 默 认 为 守 护 线 程。
线程池 ExecuteService 启动后，应该关闭
tfish的专栏
08-27 2708
当使用 ExecutorService 启动多线程完毕之后，应该关闭它，这样才能保证线程不会继续保持运行状态。 举例来说，如果程序通过 main() 方法启动，并且主线程退出了程序，如果还有一个活动的 ExecutorService 存在于程序中，那么程序将会继续保持运行状态。 启动状态的 ExecutorService 会阻止 Java 虚拟机关闭。 为了关闭 ExecutorServic...
ExecutorService 中 shutdown()、shutdownNow()、awaitTermination() 的区别及使用
justlpf的专栏
05-16 1776
但是一个 app 总有结束的时刻，当 app 结束时，ExecutorService 却并不会终止，它将导致 JVM 继续存活并运行。所以，shutdownNow() 并不代表线程池就一定立即就能退出，它也可能必须要等待所有正在执行的任务都执行完成了才能退出。如果你的 app 需要随时响应处理新提交的任务，那。是阻塞的，返回结果是线程池是否已停止（true/false）；2. 已经提交的任务（包括正在跑的和队列中等待的）,会继续执行完成；方法来实现的，这种方法的作用有限，如果线程中没有。
Java中ExecutorService线程池的使用(Runnable和Callable多线程实现)
BADAO_LIUMANG_QIZHI的博客
08-09 7644
线程的创建和释放，需要占用不小的内存和资源。如果每次需要使用线程时，都new 一个Thread的话，难免会造成资源的浪费，而且可以无限制创建，之间相互竞争，会导致过多占用系统资源导致系统瘫痪。不利于扩展，比如如定时执行、定期执行、线程中断，所以很有必要了解下ExecutorService的使用。ExecutorService是Java提供的线程池，也就是说，每次我们需要使用线程的时候，可以通过ExecutorService获得线程。...
使用ExecutorService来停止线程服务
程序那些事
04-08 1万+
文章目录使用shutdown使用shutdownNow 使用ExecutorService来停止线程服务 之前的文章中我们提到了ExecutorService可以使用shutdown和shutdownNow来关闭。 这两种关闭的区别在于各自的安全性和响应性。shutdownNow强行关闭速度更快，但是风险也更大，因为任务可能正在执行的过程中被结束了。而shutdown正常关闭虽然速度比较慢，但是却...
JAVA多线程—Callable详解
热门推荐
m0_61160520的博客
07-10 1万+
Callable作为除Thread和Runnable外第三种线程创建方式， - Callable提高响应速度（减少了创建新线程的时间） - Callable降低资源消耗（重复利用线程池中线程，不需要每次都创建） - Callable便于线程管理
ExecutorService
05-31
ExecutorService 是 Java 中 Executor 框架的核心接口之一，它提供了一种线程池的实现方式，可以方便地管理多个线程的生命周期，并提供了一些有用的方法，比如提交任务、获取任务执行结果等。 ExecutorService 接口...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值