Executor、ExecutorService 和 Executors 三者的继承关系和不同点

最新推荐文章于 2025-02-01 00:12:48 发布

猎人在吃肉

最新推荐文章于 2025-02-01 00:12:48 发布

阅读量2.9k

点赞数 8

分类专栏： # Java高级 Java基础面试

原文链接：https://www.baidu.com

版权

Java基础同时被 3 个专栏收录

74 篇文章

订阅专栏

面试

60 篇文章

订阅专栏

Java高级

42 篇文章

订阅专栏

文章目录

一、Executor、ExecutorService 和 Executors 继承关系和UML类图

Executor, ExecutorService, Executors 这三者均是 Java Executor 框架的类，用来提供线程池的功能。

因为创建和管理线程非常销耗资源，并且操作系统通常对线程数有限制，所以建议使用线程池来并发执行任务，而不是每次请求进来时创建一个线程。

使用线程池不仅可以提高应用的响应时间，还可以避免 java.lang.OutOfMemoryError: unable to create new native thread 之类的错误。

在 Java 1.5 及之前，开发者需要关心线程池的创建和管理，但在 Java 1.5 之后， Executor 框架提供了多种内置的线程池，例如：FixedThreadPool ( 包含固定数目的线程 ) 、CachedThreadPool ( 可根据需要创建新的线程 ) 等等。

在这里插入图片描述

1.1、三者的继承关系

一、线程池的体系结构：
    Executor 负责线程的使用和调度的 根接口
	|--ExecutorService  接口： 线程池的主要接口。增加了返回Future 对象
		|--ThreadPoolExecutor 线程池的实现类
		|--ScheduledExceutorService 接口： 负责线程的调度
			|--ScheduledThreadPoolExecutor ： 继承ThreadPoolExecutor，实现了ScheduledExecutorService
				
	
二、工具类 ： Executors
ExecutorService pool = Executors.newFixedThreadPool() ： 创建固定大小的线程池
ExecutorService pool = Executors.newCachedThreadPool() ： 缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量。
ExecutorService pool = Executors.newSingleThreadExecutor() ：创建单个线程池。 线程池中只有一个线程
		
ScheduledExecutorService pool = Executors.newScheduledThreadPool() ： 创建固定大小的线程，可以延迟或定时的执行任务

二、Executor：根接口

三者最主要的区别是 Executor 是一个抽象层面的 根接口 。

public interface Executor {
    void execute(Runnable command);
}

Executor 与 Thread 的不同：

不同于 Thread 类将任务和执行耦合在一起， Executor 将 任务本身和执行任务分离 。
可以阅读 difference between Thread and Executor 来了解 Thread 和 Executor 间更多的不同。

三、ExecutorService：接口

ExecutorService 接口，对 Executor 接口进行了扩展，提供了返回 Future 对象，终止，关闭线程池等方法。

当调用 shutdown()时，线程池会停止接受新的任务，但会完成正在 pending 中的任务。

ExecutorService 部分代码如下：

public interface ExecutorService extends Executor {
    void shutdown();
    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
							 long timeout, TimeUnit unit) throws InterruptedException;
}

3.1、`Future` 接口

Future 提供了异步执行，无需等待任务执行的完成，只要提交需要执行的任务，然后在需要时检查 Future 是否已经有了结果，如果任务已经执行完成，就可以通过 Future.get() 方法获得执行结果。

Future 的方法：

返回值	方法名	说明
`boolean`	`cancel(boolean mayInterruptIfRunning)`	试图取消执行这一任务。
`V`	`get()`	如果有必要等待计算完成,然后获取它的结果。
`boolean`	`isCancelled()`	返回 `true`如果这个任务被取消之前完成正常。
`boolean`	`isDone()`	返回 `true`如果这个任务完成。

需要注意的是，Future.get() 方法是一个阻塞式的方法，如果调用时任务还没有完成，会等待直到任务执行结束。

通过 ExecutorService.submit() 方法返回的 Future 对象，还可以取消任务的执行。
Future 提供了 cancel() 方法用来取消执行 pending 中的任务。

四、Executors 是一个工具类

Executors 类似于 Collections 、Arrays 等，是一个工具类，提供工厂方法来创建不同类型的线程池。

Executors 创建线程池的方法：

// 创建固定大小的线程池
ExecutorService  pool = Executors.newFixedThreadPool() ;

// 缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量
ExecutorService  pool = Executors.newCachedThreadPool();

// 创建单个线程池。 线程池中只有一个线程
ExecutorService  pool = Executors.newSingleThreadExecutor() ;
		
// 创建固定大小的线程，可以延迟或定时的执行任务
ScheduledExecutorService  pool = Executors.newScheduledThreadPool();

五、三者的区别

5.1、Executor 和 ExecutorService 的区别：

Executor 是负责线程的使用和调度的根接口； ExecutorService 接口继承了 Executor，也是接口。
Executor 接口定义了 execute() 方法用来接收一个 Runnable 接口的对象，而 ExecutorService 接口中的 submit() 方法可以接受 Runnable 和 Callable 接口的对象。
Executor 中的 execute() 方法不返回任何结果，而 ExecutorService 中的 submit()方法可以通过一个 Future 对象返回运算结果。
除了允许客户端提交任务，ExecutorService 还提供用来控制线程池的方法。比如：调用 shutDown() 方法终止线程池。可以通过《Java Concurrency in Practice》一书了解更多关于关闭线程池和如何处理 pending 的任务的知识。

5.2、总结

下表列出了 Executor 和 ExecutorService 的区别：

Executor	ExecutorService
Executor 是 java 线程池的核心接口，用来并发执行提交的任务	ExecutorService 继随 Executor，也是接口，扩展了方法，提供了异步执行和关闭线程池的方法
只有 `execute(Runnable command)` 提交任务	增加了 `submit(Callable<T> task)` 、 `submit(Runnable task, T result)`方法提交任务
`execute()` 方法无返回值	两个 `submit()` 返回 Future 对象，可用来获取任务执行结果
不能取消任务	可以通过 `Future.cancel()` 取消 pending 中的任务
没有提供和关闭线程有关的方法	提供的关闭线程的 `shutdown()` 方法

5.3、Executors 与前面二者的区别：

Executors 类提供工厂方法用来创建不同类型的线程池。比如:：

newSingleThreadExecutor() 创建一个只有一个线程的线程池，
newFixedThreadPool(int numOfThreads) 来创建固定线程数的线程池，
newCachedThreadPool() 可以根据需要创建新的线程，但如果已有线程是空闲的会重用已有线程。

5.4、ThreadPoolExecutor 的推荐

当ExecutorService 线程池中的线程均处于工作状态，并且线程数已达线程池允许的最大线程数时，就会采取指定的饱和策略来处理新提交的任务。

总共有四种策略：

AbortPolicy （终止执行）：默认策略。
Executor会抛出一个RejectedExecutionException运行异常到调用者线程来完成终止。
CallerRunsPolicy（调用者线程来运行任务）：
这种策略会由调用execute方法的线程自身来执行任务，它提供了一个简单的反馈机制并能降低新任务的提交频率。
DiscardPolicy （丢弃策略）：不处理，直接丢弃提交的任务。
DiscardOldestPolicy （丢弃队列里最近的一个任务）：

如果 Executor 还未 shutdown() 的话，则丢弃工作队列的最近的一个任务，然后执行当前任务。

如果使用 Executors 的工厂方法创建的线程池，那么饱和策略都是采用默认的 AbortPolicy ，所以如果我们想当线程池已满时，使用调用者的线程来运行任务，就要自己创建线程池，指定想要的饱和策略，而不是使用 Executors 。

所以我们可以根据需要创建 ThreadPoolExecutor ( ExecutorService 接口的实现类 ) 对象，自定义一些参数，而不是调用 Executors 的工厂方法创建。

当然，在使用 Spring 框架的项目中，也可以使用 Spring 提供的 ThreadPoolTaskExecutor 类来创建线程池。ThreadPoolTaskExecutor 与 ThreadPoolExecutor 类似，也提供了许多参数用来自定义线程池，比如：核心线程池大小，线程池最大数量，饱和策略，线程活动保持时间等等。