你好赵伟

这个屌丝很懒，什么也没留下！

热门标签

了解java并发编程核心框架Executor_executors.newcachedthreadpool()

作者：你好赵伟 | 2024-03-16 03:04:50

踩

executors.newcachedthreadpool()

本文摘自java并发编程的艺术（本文摘出来用于本人学习）

在 Java 中，使用线程来异步执行任务。 Java 线程的创建与销毁需要一定的开销，如果我们

为每一个任务创建一个新线程来执行，这些线程的创建与销毁将消耗大量的计算资源。同时，

为每一个任务创建一个新线程来执行，这种策略可能会使处于高负荷状态的应用最终崩溃。

Java的线程既是工作单元，也是执行机制。

从 JDK 5 开始，把工作单元与执行机制分离开

来。工作单元包括 Runnable 和 Callable ，而 执行机制由Executor框架提供

Executor框架简介

在 HotSpot VM 的线程模型中， Java 线程（ java.lang.Thread ）被一对一映射为本地操作系统线

程。 Java 线程启动时会创建一个本地操作系统线程；当该 Java 线程终止时，这个操作系统线程

也会被回收。操作系统会调度所有线程并将它们分配给可用的 CPU 。

在上层， Java 多线程程序通常把应用分解为若干个任务 ，然后使用用 户级的调度器

（Executor框架）将这些任务映射为固定数量的线 程；在底 层，操作系统内核将这些线程映射到

硬件处理器上

Executor框架的结构

Executor框架主要由3大部分组成如下。

· 任务。包括被执行任务需要实现的接口： Runnable 接口或 Callable 接口。
任务的执行。包括任务执行机制的核心接口 Executor ，以及继承自 Executor 的

ExecutorService 接口。 Executor 框架有两个关键类实现了 ExecutorService 接口

（ ThreadPoolExecutor 和 ScheduledThreadPoolExecutor ）。

·异步计算的结果。包括接口Future和实现Future接口的FutureTask类。

Executor 是一个接口，它是 Executor 框架的基础，它将任务的提交与任务的执行分离开

来。

·ThreadPoolExecutor是线程池的核心实现类，用来执行被提交的任务。
ScheduledThreadPoolExecutor是一个实现类，可以在给定的延迟后运行命令，或者定期执行命令。ScheduledThreadPoolExecutor比Timer更灵活，功能更强大。 ·Future接口和实现
Future接口的FutureTask类，代表异步计算的结果。
Runnable接口和Callable接口的实现类，都可以被ThreadPoolExecutor或Scheduled- ThreadPoolExecutor执行。

如何使用Excutor框架？

主线程首先要创建实现 Runnable 或者 Callable 接口的任务对象。工具类 Executors 可以把一

个 Runnable 对象封装为一个 Callable 对象（ Executors.callable （ Runnable task ）或

Executors.callable （ Runnable task ， Object resule ））。

然后可以把 Runnable 对象直接交给 ExecutorService 执行（ ExecutorService.execute （ Runnable

command ））；或者也可以把 Runnable 对象或 Callable 对象提交给 ExecutorService 执行（ Executor-Service.submit （ Runnable task ）或 ExecutorService.submit （ Callable<T>task ））。

如果执行 ExecutorService.submit （ … ）， ExecutorService 将返回一个实现 Future 接口的对象

（到目前为止的 JDK 中，返回的是 FutureTask 对象）。由于 FutureTask 实现了 Runnable ，程序员也可以创建 FutureTask ，然后直接交给 ExecutorService 执行。

最后，主线程可以执行 FutureTask.get() 方法来等待任务执行完成。主线程也可以执行 FutureTask.cancel （ boolean mayInterruptIfRunning ）来取消此任务的执行。

Excutor框架的成员

Executor 框架的主要成员： ThreadPoolExecutor 、 ScheduledThreadPoolExecutor 、

Future 接口、 Runnable 接口、 Callable 接口和 Executors 。

（ 1 ） ThreadPoolExecutor

ThreadPoolExecutor 通常使用工厂类 Executors 来创建。 Executors 可以创建 3 种类型的

ThreadPoolExecutor：SingleThreadExecutor、FixedThreadPool和CachedThreadPool。

1 ） FixedThreadPool 。下面是 Executors 提供的，创建使用固定线程数的 FixedThreadPool 的

API

public static ExecutorService newFixedThreadPool(int nThreads)

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactorythreadFacto

FixedThreadPool 适用于为了满足资源管理的需求，而需要限制当前线程数量的应用场

景，它适用于负载比较重的服务器。

2） SingleThreadExecutor 。下面是 Executors 提供的，创建使用单个线程的 SingleThread-

Executor 的 API 。

public static ExecutorService newSingleThreadExecutor()

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)

SingleThreadExecutor 适用于需要保证顺序地执行各个任务；并且在任意时间点，不会有多

个线程是活动的应用场景。

3 ） CachedThreadPool 。下面是 Executors 提供的，创建一个会根据需要创建新线程的

CachedThreadPool 的 API 。

public static ExecutorService newCachedThreadPool()

public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)

CachedThreadPool 是大小无界的线程池，适用于执行很多的短期异步任务的小程序，或者

是负载较轻的服务器。

（ 2 ） ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor 通常使用工厂类 Executors 来创建。 Executors 可以创建 2 种类

型的 ScheduledThreadPoolExecutor ，如下。

ScheduledThreadPoolExecutor。包含若干个线程的ScheduledThreadPoolExecutor。
SingleThreadScheduledExecutor。只包含一个线程的ScheduledThreadPoolExecutor。

下面是工厂类 Executors 提供的，创建固定个数线程的 ScheduledThreadPoolExecutor 的 API 。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize,threadFactory）

ScheduledThreadPoolExecutor 适用于需要多个后台线程执行周期任务，同时为了满足资源

管理的需求而需要限制后台线程的数量的应用场景。下面是 Executors 提供的，创建单个线程

的 SingleThreadScheduledExecutor 的 API 。

public static ScheduledExecutorService newSingleThreadScheduledExecutor()

public static ScheduledExecutorService newSingleThreadScheduledExecutor

(ThreadFactory threadFactory)

SingleThreadScheduledExecutor 适用于需要单个后台线程执行周期任务，同时需要保证顺

序地执行各个任务的应用场景。

（ 3 ） Future 接口

Future 接口和实现 Future 接口的 FutureTask 类用来表示异步计算的结果。当我们把 Runnable

接口或 Callable 接口的实现类提交（ submit ）给 ThreadPoolExecutor 或

ScheduledThreadPoolExecutor 时， ThreadPoolExecutor 或 ScheduledThreadPoolExecutor 会向我们返回一个 FutureTask 对象

<T> Future<T> submit(Callable<T> task)

<T> Future<T> submit(Runnable task, T result)

Future<> submit(Runnable task)

有一点需要读者注意，到目前最新的 JDK 8 为止， Java 通过上述 API 返回的是一个

FutureTask 对象。但从 API 可以看到， Java 仅仅保证返回的是一个实现了 Future 接口的对象。在将

来的 JDK 实现中，返回的可能不一定是 FutureTask 。

（ 4 ） Runnable 接口和 Callable 接口

Runnable 接口和 Callable 接口的实现类，都可以被 ThreadPoolExecutor 或 Scheduled-

ThreadPoolExecutor 执行。它们之间的区别是 Runnable 不会返回结果，而 Callable 可以返回结

果

除了可以自己创建实现 Callable 接口的对象外，还可以使用工厂类 Executors 来把一个

Runnable 包装成一个 Callable 。

下面是 Executors 提供的，把一个 Runnable 包装成一个 Callable 的 API 。

public static Callable<Object> callable(Runnable task) // 假设返回对象 Callable1

下面是Executors提供的，把一个Runnable和一个待返回的结果包装成一个Callable的API。

public static <T> Callable<T> callable(Runnable task, T result) // 假设返回对象Callable2

前面讲过，当我们把一个 Callable 对象（比如上面的 Callable1 或 Callable2 ）提交给

ThreadPoolExecutor 或 ScheduledThreadPoolExecutor 执行时， submit （ … ）会向我们返回一个

FutureTask 对象。我们可以执行 FutureTask.get() 方法来等待任务执行完成。当任务成功完成后

FutureTask.get() 将返回该任务的结果。例如，如果提交的是对象 Callable1 ， FutureTask.get() 方法

将返回 null ；如果提交的是对象 Callable2 ， FutureTask.get() 方法将返回 result 对象。

下篇将详解 ThreadPoolExecutor

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/246583?site