ExecutorService生命周期

最新推荐文章于 2023-12-08 08:02:29 发布
最新推荐文章于 2023-12-08 08:02:29 发布
阅读量1.6w 收藏 9
点赞数 2
分类专栏： javase学习

转自http://victorzhzh.iteye.com/blog/1010359

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. }  
public interface ExecutorService extends Executor {
void shutdown();
List<Runnable> shutdownNow();
boolean isShutdown();
boolean isTerminated();
boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
}

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

 

首先，我们需要创建一个任务代码，这段任务代码主要是随机生成含有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. }  
/**
 * 随机生成10个字符的字符串
 * @author dream-victor
 *
 */
public class Task1 implements Callable<String> {

	@Override
	public String call() throws Exception {
		String base = "abcdefghijklmnopqrstuvwxyz0123456789";
		Random random = new Random();
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < 10; i++) {
			int number = random.nextInt(base.length());
			sb.append(base.charAt(number));
		}
		return sb.toString();
	}

}

 然后，我们还需要一个长任务，这里我们默认是沉睡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. }  
/**
 * 长时间任务
 * 
 * @author dream-victor
 * 
 */
public class LongTask implements Callable<String> {

	@Override
	public String call() throws Exception {
		TimeUnit.SECONDS.sleep(10);
		return "success";
	}

}

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("线程池已经关闭");  
ExecutorService service = Executors.newFixedThreadPool(4);
service.submit(new Task1());
service.submit(new Task1());
service.submit(new LongTask());
service.submit(new Task1());

service.shutdown();

while (!service.awaitTermination(1, TimeUnit.SECONDS)) {
	System.out.println("线程池没有关闭");
}
System.out.println("线程池已经关闭");

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

Java代码 复制代码  收藏代码
  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("线程池已经关闭");  
		ExecutorService service = Executors.newFixedThreadPool(3);
		service.submit(new LongTask());
		service.submit(new LongTask());
		service.submit(new LongTask());
		service.submit(new LongTask());
		service.submit(new LongTask());
		
		List<Runnable> runnables = service.shutdownNow();
		System.out.println(runnables.size());

		while (!service.awaitTermination(1, TimeUnit.MILLISECONDS)) {
			System.out.println("线程池没有关闭");
		}
		System.out.println("线程池已经关闭");

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

Java代码 复制代码  收藏代码
  1. 2  
  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());  
		ExecutorService service = Executors.newFixedThreadPool(3);
		service.submit(new Task1());
		service.submit(new Task1());
		service.submit(new LongTask());

		service.shutdown();
		System.out.println(System.currentTimeMillis());
		while (!service.isTerminated()) {
		}
		System.out.println(System.currentTimeMillis());

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

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

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

 

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

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

 

 

sayyanfu
关注
专栏目录
ExecutorService 生命周期
qq_36285899的博客
03-24 815
最近使用executor 写了一个小程序，发现线程池一直不关闭，必须要手动关闭，于是查阅了相关资料： 原文链接 ExecutorService接口继承了Executor接口，定义了一些生命周期的方法 Java代码 publicinterfaceExecutorServiceextendsExecutor{ voidshutdown(); List<Runnable>shutdownNow(); booleanisShutdown(); boolea...
Java ExecutorService：你真的了解它吗？
最新发布
忆~遂愿的博客
08-05 3944
Java ExecutorService是Java并发编程中一个强大的工具，它提供了一种管理线程生命周期和执行多个异步任务的方式。它是基于线程池的概念，能够有效地管理和复用线程，从而提高程序的性能和资源利用率。ExecutorService通过隐藏线程的创建和管理细节，简化了多线程编程。它可以创建不同类型的线程池，如固定大小线程池、缓存线程池和单线程线程池，以满足不同场景下的需求。任务提交后，ExecutorService负责调度和执行这些任务，并管理它们的执行状态。
线程池时候当程序结束时候记得调用shutdown关闭线程池
沮丧的南瓜
03-15 2081
一、使用线程池时候当程序结束时候记得调用shutdown关闭线程池 日常开发中为了便于线程的有效复用，线程池是经常会被用的工具，然而线程池使用完后如果不调用shutdown会导致线程池资源一直不会被释放。下面通过简单例子来说明该问题。 1、问题复现 下面通过一个例子说明当不调用线程池对象的shutdown方法后，当线程池里面的任务执行完毕后主线程这个JVM不会退出。 public class TestShutDown { static void asynExecuteOne() {
线程池程序不会结束与shutdown有关
palwang723的专栏
09-28 1072
使用线程池时，在main完成之前没的调用shutdonw使得，java进程不会结束。线程池默认的线程不是“守护线程”，线程池的timeout 大于 0时，code数量的线程是不会终止的。所以，当所有任务完成后，java程序不会结束。 ExecutorService.shutdown()将使之前通过Executor.execute()提交的任务运行结束后关闭线程池。Executor...
线程池,Executors,Callable,Lock,使用线程池,线程池的相关方法
W_a_n_g_c_h_i的博客
02-23 233
当 任 务 执 行 时 间 大 于 间 隔 时 间 ,下 一次 任 务 将 会 在 上 一 次 任 务 结束后 ,立 即 执 行。> task ):给线程池提交线程任务。下 一 次 任 务 开 始 时 间 -上 一 次 任 务 结束 时 间 =间 隔 时 间。> submit(Runnable task):给线程池提交线程任务。3,关 闭 线 程 池 ,注 意 抢 占 线 程 池 中 的 线 程 默 认 为 守 护 线 程。
java 线程的生命周期详解
08-30
在实际编程中，我们还可以使用线程池来管理线程，比如`ExecutorService`，它可以帮助我们更好地控制线程的创建和销毁，减少线程生命周期的开销。此外，线程间的同步和通信机制，如`synchronized`关键字、`wait()`, `...
java ExecutorService使用方法详解
09-01
线程的生命周期由`ExecutorService`内部管理，如果线程完成了它的任务，`ExecutorService`会决定是否回收这个线程。 6. **线程的生命周期** 在`JobThread`的`run()`方法中，线程会持续运行，直到主线程将其从`...
Java 线程池ExecutorService详解及实例代码
09-01
线程池的主要目的是为了优化线程的生命周期管理。在处理大量并发任务时，如果每个任务都单独创建线程，那么频繁的线程创建和销毁会带来很大的性能开销。线程池可以预先创建一定数量的线程，待有任务提交时直接复用，...
java多线程并发executorservice(任务调度)类
09-04
4. 可以控制线程池的生命周期，如通过 `shutdown` 方法优雅地关闭线程池。 了解这些知识点对于编写高效、可控的并发程序至关重要。在实际应用中，可以根据任务的特性选择合适的线程池配置，以达到最佳性能和资源...
线程的生命周期.pdf
09-30
Java线程的生命周期是编程中一个关键的概念，尤其是在多线程编程中。线程的生命周期主要包括以下几个阶段： 1. **创建**：线程的创建可以通过两种方式：直接实例化Thread类或者继承Thread类并重写run()方法。例如，...
Java中ExecutorService线程池的使用(Runnable和Callable多线程实现)
BADAO_LIUMANG_QIZHI的博客
08-09 7573
线程的创建和释放，需要占用不小的内存和资源。如果每次需要使用线程时，都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便于线程管理
Executors、Callable实现的多线程任务
qq_34934864的博客
12-13 236
问程序结束运行时间。 ​ import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurre...
ExecutorService、Callable、Future实现有返回结果的多线程原理解析
朱季谦
12-08 1300
ExecutorService、Callable、Future实现有返回结果的多线程原理解析
创建线程thread、runable、callable、ExecutorService 的四种方式
qq_41587243的博客
05-06 587
创建线程的三种方式 1.继承Thread类 2.实现Runnable类 3.实现Callable类 具体如下： 一、继承Thread类 继承Thread类创建线程的步骤为： （1）创建一个类继承Thread类，重写run()方法，将所要完成的任务代码写进run()方法中； （2）创建Thread类的子类的对象； （3）调用该对象的start()方法，该start()方法表示先开启线程，然后调用ru...
scheduledexecutorservice 只执行一次_ScheduledExecutorService原理分析
weixin_39800971的博客
11-27 2266
最近跟别人聊天，别人问我了一个问题ScheduledExecutorService的原理是啥呢？说实话，一脸懵逼的就过去了，虽然知道这么个东西，说实话也没细看实现的原理，今天就来分析一下吧。我们先从一段代码开始今天的旅程。ScheduledExecutorService scheduledExecutorService = new ScheduledThreadPoolExecutor(1);这里...
多线程之什么是线程池，如何使用？
Timon_Kris的博客
04-23 1249
1.线程池是什么？如何理解？为什么要使用线程池？作用？ A：什么是线程池 假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。线程池不仅调整T1,T3产生的时间段，.
ExecutorService
05-31
ExecutorService 是 Java 中 Executor 框架的核心接口之一，它提供了一种线程池的实现方式，可以方便地管理多个线程的生命周期，并提供了一些有用的方法，比如提交任务、获取任务执行结果等。 ExecutorService 接口继承自 Executor 接口，它提供了一些额外的方法，比如： 1. `submit(Runnable task)`：提交一个 Runnable 任务到线程池中执行，返回一个 Future 对象，可以用来获取任务执行结果或者取消任务。 2. `submit(Callable<T> task)`：提交一个 Callable 任务到线程池中执行，返回一个 Future 对象，可以用来获取任务执行结果或者取消任务。 3. `shutdown()`：关闭线程池，等待所有任务执行完成后关闭线程池。 4. `shutdownNow()`：立即关闭线程池，尝试中断所有正在执行的任务。 5. `awaitTermination(long timeout, TimeUnit unit)`：等待所有任务执行完成后关闭线程池，最长等待时间为 timeout，并且时间单位为 unit。 使用 ExecutorService 可以方便地创建线程池，并提交任务到线程池中执行，通过控制线程池的大小和任务队列的长度等参数，可以有效地避免线程数量过多和优先级不合理导致的阻塞和资源浪费问题。同时，ExecutorService 还提供了一些有用的方法，比如获取任务执行结果、取消任务等，可以方便地管理任务的执行。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值