Appearance
1 FixedThreadPool
1.1 介绍
FixedThreadPool被称为可重用固定线程数的线程池。通过 Executors 类中的相关源代码来看一下相关实现：
java
/**
* Creates a thread pool that reuses a fixed number of threads
* operating off a shared unbounded queue, using the provided
* ThreadFactory to create new threads when needed. At any point,
* at most {@code nThreads} threads will be active processing
* tasks. If additional tasks are submitted when all threads are
* active, they will wait in the queue until a thread is
* available. If any thread terminates due to a failure during
* execution prior to shutdown, a new one will take its place if
* needed to execute subsequent tasks. The threads in the pool will
* exist until it is explicitly {@link ExecutorService#shutdown
* shutdown}.
*
* @param nThreads the number of threads in the pool
* @param threadFactory the factory to use when creating new threads
* @return the newly created thread pool
* @throws NullPointerException if threadFactory is null
* @throws IllegalArgumentException if {@code nThreads <= 0}
*/
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory);
}另外还有一个FixedThreadPool的实现方法，和上面的类似，所以这里不多做阐述：
java
/**
* Creates a thread pool that reuses a fixed number of threads
* operating off a shared unbounded queue. At any point, at most
* {@code nThreads} threads will be active processing tasks.
* If additional tasks are submitted when all threads are active,
* they will wait in the queue until a thread is available.
* If any thread terminates due to a failure during execution
* prior to shutdown, a new one will take its place if needed to
* execute subsequent tasks. The threads in the pool will exist
* until it is explicitly {@link ExecutorService#shutdown shutdown}.
*
* @param nThreads the number of threads in the pool
* @return the newly created thread pool
* @throws IllegalArgumentException if {@code nThreads <= 0}
*/
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}从上面源代码可以看出新创建的 FixedThreadPool 的 corePoolSize 和 maximumPoolSize 都被设置为 nThreads，这个 nThreads 参数是我们使用的时候自己传递的。
1.2 执行任务过程介绍
FixedThreadPool 的 execute() 方法运行示意图（该图片来源：《Java 并发编程的艺术》）：
示意图「FixThreadPool的execute()执行示意图」已随上游仓库（DemoTransfer）失效，2026-10 标注%E6%96%B9%E6%B3%95%E8%BF%90%E8%A1%8C%E7%A4%BA%E6%84%8F%E5%9B%BE.png)
上图说明：
* 如果当前运行的线程数小于 corePoolSize，再来新任务就创建新的线程来执行任务； * 当前运行的线程数等于 corePoolSize 后，再来新任务会将任务加入 LinkedBlockingQueue；
- 线程池中的线程执行完 手头的任务后，会在循环中反复从
LinkedBlockingQueue中获取任务来执行；
1.3 为什么不推荐使用FixedThreadPool？
FixedThreadPool 使用无界队列 LinkedBlockingQueue（队列的容量为 Integer.MAX_VALUE）作为线程池的工作队列。这会对线程池带来如下影响：
- 当线程池中的线程数达到
corePoolSize后，新任务将在无界队列中等待。因此线程池中的线程数不会超过corePoolSize； - 由于使用无界队列时
maximumPoolSize将是一个无效参数，因为任务队列不可能满。所以，源码中创建的FixedThreadPool的corePoolSize和maximumPoolSize是同一个值。 - 由于 1 和 2，使用无界队列时
keepAliveTime将是一个无效参数； - 运行中的
FixedThreadPool（未执行shutdown()或shutdownNow()）不会拒绝任务。任务多的时候会导致 OOM（内存溢出）。
2 SingleThreadExecutor
2.1 介绍
SingleThreadExecutor是只有一个线程的线程池。下面看看SingleThreadExecutor 的实现：
java
/**
* Creates an Executor that uses a single worker thread operating
* off an unbounded queue, and uses the provided ThreadFactory to
* create a new thread when needed. Unlike the otherwise
* equivalent {@code newFixedThreadPool(1, threadFactory)} the
* returned executor is guaranteed not to be reconfigurable to use
* additional threads.
*
* @param threadFactory the factory to use when creating new
* threads
*
* @return the newly created single-threaded Executor
* @throws NullPointerException if threadFactory is null
*/
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory));
}java
/**
* Creates an Executor that uses a single worker thread operating
* off an unbounded queue. (Note however that if this single
* thread terminates due to a failure during execution prior to
* shutdown, a new one will take its place if needed to execute
* subsequent tasks.) Tasks are guaranteed to execute
* sequentially, and no more than one task will be active at any
* given time. Unlike the otherwise equivalent
* {@code newFixedThreadPool(1)} the returned executor is
* guaranteed not to be reconfigurable to use additional threads.
*
* @return the newly created single-threaded Executor
*/
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}从上面源代码可以看出新创建的 SingleThreadExecutor 的 corePoolSize 和 maximumPoolSize 都被设置为 1.其他参数和 FixedThreadPool 相同。
2.2 执行任务过程介绍
SingleThreadExecutor 的运行示意图（该图片来源：《Java 并发编程的艺术》）：
上图说明;
- 如果当前运行的线程数少于 corePoolSize，则创建一个新的线程执行任务；
- 当前线程池中有一个运行的线程后，将任务加入
LinkedBlockingQueue - 线程执行完当前的任务后，会在循环中反复从
LinkedBlockingQueue中获取任务来执行；
2.3 为什么不推荐使用SingleThreadExecutor？
SingleThreadExecutor 使用无界队列 LinkedBlockingQueue 作为线程池的工作队列（队列的容量为 Integer.MAX_VALUE）。SingleThreadExecutor 使用无界队列作为线程池的工作队列会对线程池带来的影响与 FixedThreadPool 相同。说简单点就是可能会导致 OOM（内存溢出）。
3 CachedThreadPool
3.1 介绍
CachedThreadPool是一个会根据需要创建新线程的线程池。下面通过源码来看看 CachedThreadPool 的实现：
java
/**
* Creates a thread pool that creates new threads as needed, but
* will reuse previously constructed threads when they are
* available, and uses the provided
* ThreadFactory to create new threads when needed.
* @param threadFactory the factory to use when creating new threads
* @return the newly created thread pool
* @throws NullPointerException if threadFactory is null
*/
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(),
threadFactory);
}java
/**
* Creates a thread pool that creates new threads as needed, but
* will reuse previously constructed threads when they are
* available. These pools will typically improve the performance
* of programs that execute many short-lived asynchronous tasks.
* Calls to {@code execute} will reuse previously constructed
* threads if available. If no existing thread is available, a new
* thread will be created and added to the pool. Threads that have
* not been used for sixty seconds are terminated and removed from
* the cache. Thus, a pool that remains idle for long enough will
* not consume any resources. Note that pools with similar
* properties but different details (for example, timeout parameters)
* may be created using {@link ThreadPoolExecutor} constructors.
*
* @return the newly created thread pool
*/
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}CachedThreadPool 的 corePoolSize 被设置为空（0），maximumPoolSize 被设置为 Integer.MAX.VALUE，即它是无界的，这也就意味着如果主线程提交任务的速度高于 maximumPool 中线程处理任务的速度时，CachedThreadPool 会不断创建新的线程。极端情况下，这样会导致耗尽 cpu 和内存资源。
3.2 执行任务过程介绍
CachedThreadPool 的 execute()方法的执行示意图（该图片来源：《Java 并发编程的艺术》）：
示意图「CachedThreadPool的execute()执行示意图」已随上游仓库（DemoTransfer）失效，2026-10 标注%E6%96%B9%E6%B3%95%E6%89%A7%E8%A1%8C%E7%A4%BA%E6%84%8F%E5%9B%BE.png)
上图说明：
- 首先执行
SynchronousQueue.offer(Runnable task)提交任务到任务队列。如果当前maximumPool中有闲线程正在执行SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)。那么主线程执行offer操作与空闲线程执行的poll操作配对成功。主线程把任务交给空闲线程执行，execute()方法执行完成。否则执行下面的步骤 2； - 当初始
maximumPool为空，或其中没有空闲线程时，将没有线程执行SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)。这时步骤 1 将失败。此时CachedThreadPool会创建新线程执行任务，execute方法执行完成；
3.3 为什么不推荐使用CachedThreadPool？
CachedThreadPool允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致 OOM。
4 ScheduledThreadPoolExecutor
ScheduledThreadPoolExecutor 主要用来在给定的延迟后运行任务，或者定期执行任务。 这个在实际项目中基本不会被用到，所以对这部分大家只需要简单了解一下它的思想。关于如何在Spring Boot 中 实现定时任务，可以查看这篇文章<a href="https://github.com/Snailclimb/springboot-guide/blob/master/docs/advanced/SpringBoot-ScheduleTasks.md">《5分钟搞懂如何在Spring Boot中Schedule Tasks》</a>
4.1 简介
ScheduledThreadPoolExecutor 使用的任务队列 DelayQueue 封装了一个 PriorityQueue。PriorityQueue 会对队列中的任务排序。执行所需时间短的放在前面先被执行(ScheduledFutureTask 的 time 变量小的先执行)。如果执行所需时间相同则先提交的任务将被先执行(ScheduledFutureTask 的 squenceNumber 变量小的先执行)。
ScheduledThreadPoolExecutor 和 Timer 的比较：
Timer对系统时钟的变化敏感，ScheduledThreadPoolExecutor不是；Timer只有一个执行线程，因此长时间运行的任务可以延迟其他任务。ScheduledThreadPoolExecutor可以配置任意数量的线程。 此外，如果你想（通过提供ThreadFactory），你可以完全控制创建的线程;- 在
TimerTask中抛出的运行时异常会杀死一个线程，从而导致Timer死机:-( ...即计划任务将不再运行。ScheduledThreadExecutor不仅捕获运行时异常，还允许您在需要时处理它们（通过重写afterExecute方法ThreadPoolExecutor）。抛出异常的任务将被取消，但其他任务将继续运行。
综上，在 JDK1.5 之后，你没有理由再用 Timer 调度任务了。
备注：
Quartz是一个由 java 编写的任务调度库，由OpenSymphony组织开源出来。在实际项目开发中使用Quartz的还是居多，推荐使用Quartz。因为Quartz理论上能够同时对上万个任务调度。它拥有丰富的功能特性，例如任务调度、任务持久化、可集群化、插件。
4.2 运行机制
ScheduledThreadPoolExecutor 的执行主要分为两大部分：
- 当调用
ScheduledThreadPoolExecutor的scheduleAtFixedRate()或scheduleWirhFixedDelay()时，系统向DelayQueue添加一个ScheduledFutureTask。这个任务实现了RunnableScheduledFuture接口。 - 线程池中的线程从
DelayQueue中获取ScheduledFutureTask。 - 线程池中的线程执行任务。
ScheduledThreadPoolExecutor 为了实现周期性的执行任务，对 ThreadPoolExecutor 做了如下修改：
- 使用
DelayQueue作为任务队列； - 获取任务的方不同
- 执行周期任务后，增加了额外的处理
4.3 ScheduledThreadPoolExecutor 执行周期任务的步骤
- 线程 1 从
DelayQueue中获取已到期的ScheduledFutureTask（DelayQueue.take()）。到期任务是指ScheduledFutureTask的time大于等于当前系统的时间； - 线程 1 执行这个
ScheduledFutureTask； - 线程 1 修改
ScheduledFutureTask的time变量为下次将要被执行的时间； - 线程 1 把这个修改
time之后的ScheduledFutureTask放回DelayQueue中（DelayQueue.add())。