目录
一、线程池介绍
线程池就是管理一系列线程的资源池，其提供了一种限制和管理线程资源的方式。每个线程池还维护一些基本统计信息，例如已完成任务的数量。
使用线程池的好处：
- 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
- 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
- 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
线程池一般用于执行多个不相关联的耗时任务，没有多线程的情况下，任务顺序执行，使用了线程池的话可让多个不相关联的任务同时执行。
二、Executors
Executors 提供了四种线程池的创建：newCachedThreadPool、newFixedThreadPool、newSingleThreadExecutor、newScheduledThreadPool
newFixedThreadPool：创建一个拥有 n 个线程的线程池
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}- 核心线程数 == 最大线程数（没有救急线程被创建），因此也无需超时时间
- LinkedBlockingQueue 是一个单向链表实现的阻塞队列，默认大小为
Integer.MAX_VALUE，也就是无界队列，可以放任意数量的任务，在任务比较多的时候会导致 OOM（内存溢出） - 适用于任务量已知，相对耗时的长期任务
newCachedThreadPool：创建一个可扩容的线程池
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}-
核心线程数是 0， 最大线程数是 29 个 1，全部都是救急线程（60s 后可以回收），可能会创建大量线程，从而导致OOM
-
SynchronousQueue 作为阻塞队列，没有容量，对于每一个 take 的线程会阻塞直到有一个 put 的线程放入元素为止（类似一手交钱、一手交货）
-
适合任务数比较密集，但每个任务执行时间较短的情况
newSingleThreadExecutor：创建一个只有 1 个线程的单线程池
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}-
保证所有任务按照指定顺序执行，线程数固定为 1，任务数多于 1 时会放入无界队列排队，任务执行完毕，这唯一的线程也不会被释放
对比：
-
创建一个单线程串行执行任务，如果任务执行失败而终止那么没有任何补救措施，线程池会新建一个线程，保证池的正常工作
-
Executors.newSingleThreadExecutor() 线程个数始终为 1，不能修改。FinalizableDelegatedExecutorService 应用的是装饰器模式，只对外暴露了 ExecutorService 接口，因此不能调用 ThreadPoolExecutor 中特有的方法
原因：父类不能直接调用子类中的方法，需要反射或者创建对象的方式，可以调用子类静态方法
-
Executors.newFixedThreadPool(1) 初始时为 1，可以修改。对外暴露的是 ThreadPoolExecutor 对象，可以强转后调用 setCorePoolSize 等方法进行修改
三、ThreadPoolExecutor
（一）线程池参数
/**
* 用给定的初始参数创建一个新的ThreadPoolExecutor。
*/
public ThreadPoolExecutor(int corePoolSize,//线程池的核心线程数量
int maximumPoolSize,//线程池的最大线程数
long keepAliveTime,//当线程数大于核心线程数时，多余的空闲线程存活的最长时间
TimeUnit unit,//时间单位
BlockingQueue<Runnable> workQueue,//任务队列，用来储存等待执行任务的队列
ThreadFactory threadFactory,//线程工厂，用来创建线程，一般默认即可
RejectedExecutionHandler handler//拒绝策略，当提交的任务过多而不能及时处理时，我们可以定制策略来处理任务
)
{
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}参数介绍：
-
corePoolSize：核心线程数，定义了最小可以同时运行的线程数量
-
maximumPoolSize：最大线程数，当队列中存放的任务达到队列容量时，当前可以同时运行的数量变为最大线程数，创建线程并立即执行最新的任务，与核心线程数之间的差值又叫救急线程数
-
keepAliveTime：救急线程最大存活时间，当线程池中的线程数量大于
corePoolSize的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等到keepAliveTime时间超过销毁 -
unit：
keepAliveTime参数的时间单位 -
workQueue：阻塞队列，存放被提交但尚未被执行的任务
-
threadFactory：线程工厂，创建新线程时用到，可以为线程创建时起名字
-
handler：拒绝策略，线程到达最大线程数仍有新任务时会执行拒绝策略
RejectedExecutionHandler 下有 4 个实现类：
-
AbortPolicy：让调用者抛出 RejectedExecutionException 异常，默认策略
-
CallerRunsPolicy：让调用者运行的调节机制，将某些任务回退到调用者，从而降低新任务的流量
-
DiscardPolicy：直接丢弃任务，不予任何处理也不抛出异常
-
DiscardOldestPolicy：放弃队列中最早的任务，把当前任务加入队列中尝试再次提交当前任务
补充：其他框架拒绝策略
-
Dubbo：在抛出 RejectedExecutionException 异常前记录日志，并 dump 线程栈信息，方便定位问题
-
Netty：创建一个新线程来执行任务
-
ActiveMQ：带超时等待（60s）尝试放入队列
-
PinPoint：它使用了一个拒绝策略链，会逐一尝试策略链中每种拒绝策略
-
线程池中各个参数的相互关系图：
（二）线程池的创建方式
方式 1：直接使用 ThreadPoolExecutor 构造函数（推荐）
通过构造函数创建线程池可以精确控制所有参数，适用于需要高度定制的场景（如生产环境）。
核心构造方法：
import java.util.concurrent.*;
public class CustomThreadPool {
public static void main(String[] args) {
// 1. 定义线程池参数
int corePoolSize = 2;
int maxPoolSize = 5;
long keepAliveTime = 30;
TimeUnit unit = TimeUnit.SECONDS;
BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(10);
ThreadFactory threadFactory = Executors.defaultThreadFactory();
RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
// 2. 创建线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
corePoolSize,
maxPoolSize,
keepAliveTime,
unit,
workQueue,
threadFactory,
handler
);
// 3. 提交任务
for (int i = 0; i < 15; i++) {
executor.execute(() -> {
System.out.println("Task executed by: " + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
// 4. 关闭线程池
executor.shutdown();
}
}方式 2：通过 Executors 工厂方法（快捷但不推荐）
Executors 工具类提供了一组预定义的线程池（底层仍是 ThreadPoolExecutor），但部分实现有资源耗尽风险（如无界队列），适用于简单场景。
通过Executors工具类可以创建多种类型的线程池，包括：
FixedThreadPool：固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。SingleThreadExecutor： 只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。CachedThreadPool： 可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。ScheduledThreadPool：给定的延迟后运行任务或者定期执行任务的线程池。
《阿里巴巴 Java 开发手册》强制线程池不允许使用
Executors去创建，而是通过ThreadPoolExecutor构造函数的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险
Executors返回线程池对象的弊端如下：
FixedThreadPool和SingleThreadExecutor:使用的是阻塞队列LinkedBlockingQueue，任务队列最大长度为Integer.MAX_VALUE，可以看作是无界的，可能堆积大量的请求，从而导致 OOM。CachedThreadPool:使用的是同步队列SynchronousQueue, 允许创建的线程数量为Integer.MAX_VALUE，如果任务数量过多且执行速度较慢，可能会创建大量的线程，从而导致 OOM。ScheduledThreadPool和SingleThreadScheduledExecutor:使用的无界的延迟阻塞队列DelayedWorkQueue，任务队列最大长度为Integer.MAX_VALUE,可能堆积大量的请求，从而导致 OOM。
（三）线程池常用的阻塞队列
1. ArrayBlockingQueue
-
特点：基于数组的有界阻塞队列
-
排序规则：FIFO（先进先出）
-
实现原理：
-
固定大小的环形数组
-
使用单个锁（ReentrantLock）控制入队和出队操作
-
-
适用场景：
-
需要控制队列大小的生产环境
-
固定大小的线程池
-
-
示例：
BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(100);2. LinkedBlockingQueue
-
特点：
-
基于链表的可选有界/无界队列
-
默认无界（容量为 Integer.MAX_VALUE）
-
-
排序规则：FIFO（先进先出）
-
实现原理：
-
链表结构
-
使用两个锁（putLock 和 takeLock）分离入队和出队操作
-
-
适用场景：
-
需要高吞吐量的场景
-
任务量可预测且不会无限增长的情况
-
-
风险：无界队列可能导致 OOM（内存溢出）
-
示例：
// 有界队列（推荐）
BlockingQueue<Runnable> boundedQueue = new LinkedBlockingQueue<>(1000);
// 无界队列（不推荐）
BlockingQueue<Runnable> unboundedQueue = new LinkedBlockingQueue<>();3. SynchronousQueue
-
特点：
-
不存储元素的阻塞队列
-
每个插入操作必须等待对应的移除操作
-
-
排序规则：
-
公平模式（FIFO）：使用队列结构
-
非公平模式（LIFO）：使用栈结构（默认）
-
-
实现原理：
-
直接传递任务给消费者线程
-
无中间存储缓冲区
-
-
适用场景：
-
需要快速创建新线程处理任务的场景
-
CachedThreadPool 的默认队列
-
-
示例：
// 默认非公平模式
BlockingQueue<Runnable> queue = new SynchronousQueue<>();
// 公平模式
BlockingQueue<Runnable> fairQueue = new SynchronousQueue<>(true);4. DelayedWorkQueue（ScheduledThreadPoolExecutor 专用）
-
特点：
-
用于定时任务线程池的内部实现
-
按延迟时间排序
-
-
排序规则：按执行时间排序（最早执行的在队首）
-
实现原理：
-
基于堆的优先级队列
-
自动调整大小
-
-
适用场景：ScheduledThreadPoolExecutor 专用
| 队列类型 | 有界性 | 锁机制 | 吞吐量 | 内存风险 | 适用场景 |
|---|---|---|---|---|---|
| ArrayBlockingQueue | 有界 | 单锁 | 中等 | 低 | 固定大小线程池 |
| LinkedBlockingQueue | 可选有界/无界 | 双锁分离 | 高 | 无界有风险 | 高吞吐量场景 |
| SynchronousQueue | 容量为0 | 无锁/CAS | 高 | 低 | 直接传递任务 |
| DelayedWorkQueue | 无界（堆结构） | 单锁 | 中等 | 中 | 定时任务调度 |
四、线程池原理
（一）工作原理
1. 创建线程池，这时没有创建线程（懒惰），等待提交过来的任务请求，调用 execute 方法才会创建线程
2. 当调用 execute() 方法添加一个请求任务时，线程池会做如下判断：
- 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务
- 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列
- 如果这时队列满了且正在运行的线程数量还小于 maximumPoolSize，那么会创建非核心线程立刻运行这个任务，对于阻塞队列中的任务不公平。这是因为创建每个 Worker（线程）对象会绑定一个初始任务，启动 Worker 时会优先执行
- 如果队列满了且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会启动饱和拒绝策略来执行
3. 当一个线程完成任务时，会从队列中取下一个任务来执行
4. 当一个线程空闲超过一定的时间（keepAliveTime）时，线程池会判断：如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉，所以线程池的所有任务完成后最终会收缩到 corePoolSize 大小
简易流程图：
设now为当前运行的线程数，core和max分别为核心线程数和最大线程数
1. 当 now < core :
- 创建新线程，执行任务
2. 当 core <= now < max :
- 如果队列未满：将任务加入队列
- 如果队列已满：创建救急线程，执行任务
3. 当 now >= max :
- 执行拒绝策略
详细流程图：
（二）常见方法的对比
1. Runnable 与 Callable
Runnable自 Java 1.0 以来一直存在，但Callable仅在 Java 1.5 中引入,目的就是为了来处理Runnable不支持的用例。Runnable 接口不会返回结果或抛出检查异常，但是 Callable 接口可以。所以，如果任务不需要返回结果或抛出异常推荐使用 Runnable 接口，这样代码看起来会更加简洁。
Runnable.java
@FunctionalInterface
public interface Runnable {
/**
* 被线程执行，没有返回值也无法抛出异常
*/
public abstract void run();
}Callable.java
@FunctionalInterface
public interface Callable<V> {
/**
* 计算结果，或在无法这样做时抛出异常。
* @return 计算得出的结果
* @throws 如果无法计算结果，则抛出异常
*/
V call() throws Exception;
}2. execute() 与 submit()
execute() 和 submit()是两种提交任务到线程池的方法，有一些区别：
- 返回值：
execute()方法用于提交不需要返回值的任务。通常用于执行Runnable任务，无法判断任务是否被线程池成功执行。submit()方法用于提交需要返回值的任务。可以提交Runnable或Callable任务。submit()方法返回一个Future对象，通过这个Future对象可以判断任务是否执行成功，并获取任务的返回值（get()方法会阻塞当前线程直到任务完成，get（long timeout，TimeUnit unit）多了一个超时时间，如果在timeout时间内任务还没有执行完，就会抛出java.util.concurrent.TimeoutException）。 - 异常处理：在使用
submit()方法时，可以通过Future对象处理任务执行过程中抛出的异常；而在使用execute()方法时，异常处理需要通过自定义的ThreadFactory（在线程工厂创建线程的时候设置UncaughtExceptionHandler对象来 处理异常）或ThreadPoolExecutor的afterExecute()方法来处理
3. shutdown（）与 shutdownNow（）
shutdown（）:关闭线程池，线程池的状态变为SHUTDOWN。线程池不再接受新任务了，但是队列里的任务得执行完毕。shutdownNow（）:关闭线程池，线程池的状态变为STOP。线程池会终止当前正在运行的任务，并停止处理排队的任务并返回正在等待执行的 List。
4. isShutDown（）与 isTerminated（）
isShutDown当调用shutdown()方法后返回为 true。isTerminated当调用shutdown()方法后，并且所有提交的任务完成后返回为 true
五、常见的线程池
（一）FixedThreadPool
FixedThreadPool 被称为可重用固定线程数的线程池。
/**
* 创建一个可重用固定数量线程的线程池
*/
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory);
}从上面源代码可以看出新创建的 FixedThreadPool 的 corePoolSize 和 maximumPoolSize 都被设置为 nThreads，这个 nThreads 参数是我们使用的时候自己传递的。
即使 maximumPoolSize 的值比 corePoolSize 大，也至多只会创建 corePoolSize 个线程。这是因为FixedThreadPool 使用的是容量为 Integer.MAX_VALUE 的 LinkedBlockingQueue（无界队列），队列永远不会被放满。
为什么不推荐使用
FixedThreadPool？
FixedThreadPool使用无界队列LinkedBlockingQueue（队列的容量为 Integer.MAX_VALUE）作为线程池的工作队列会对线程池带来如下影响：
- 当线程池中的线程数达到
corePoolSize后，新任务将在无界队列中等待，因此线程池中的线程数不会超过corePoolSize；- 由于使用无界队列时
maximumPoolSize将是一个无效参数，因为不可能存在任务队列满的情况。所以，通过创建FixedThreadPool的源码可以看出创建的FixedThreadPool的corePoolSize和maximumPoolSize被设置为同一个值。- 由于 1 和 2，使用无界队列时
keepAliveTime将是一个无效参数；- 运行中的
FixedThreadPool（未执行shutdown()或shutdownNow()）不会拒绝任务，在任务比较多的时候会导致 OOM（内存溢出）。
（二）SingleThreadExecutor
SingleThreadExecutor 是只有一个线程的线程池。
/**
*返回只有一个线程的线程池
*/
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory));
}从上面源代码可以看出新创建的 SingleThreadExecutor 的 corePoolSize 和 maximumPoolSize 都被设置为 1，其他参数和 FixedThreadPool 相同。
- 如果当前运行的线程数少于
corePoolSize，则创建一个新的线程执行任务； - 当前线程池中有一个运行的线程后，将任务加入
LinkedBlockingQueue - 线程执行完当前的任务后，会在循环中反复从
LinkedBlockingQueue中获取任务来执行；
为什么不推荐使用
SingleThreadExecutor？
SingleThreadExecutor和FixedThreadPool一样，使用的都是容量为Integer.MAX_VALUE的LinkedBlockingQueue（无界队列）作为线程池的工作队列。SingleThreadExecutor使用无界队列作为线程池的工作队列会对线程池带来的影响与FixedThreadPool相同。说简单点，就是可能会导致 OOM。
（三）CachedThreadPool
CachedThreadPool 是一个会根据需要创建新线程的线程池。
/**
* 创建一个线程池，根据需要创建新线程，但会在先前构建的线程可用时重用它。
*/
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(),
threadFactory);
}CachedThreadPool 的corePoolSize 被设置为空（0），maximumPoolSize被设置为 Integer.MAX.VALUE，即它是无界的，这也就意味着如果主线程提交任务的速度高于 maximumPool 中线程处理任务的速度时，CachedThreadPool 会不断创建新的线程。极端情况下，这样会导致耗尽 cpu 和内存资源。
- 首先执行
SynchronousQueue.offer(Runnable task)提交任务到任务队列。如果当前maximumPool中有闲线程正在执行SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)，那么主线程执行 offer 操作与空闲线程执行的poll操作配对成功，主线程把任务交给空闲线程执行，execute()方法执行完成，否则执行下面的步骤 2； - 当初始
maximumPool为空，或者maximumPool中没有空闲线程时，将没有线程执行SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)。这种情况下，步骤 1 将失败，此时CachedThreadPool会创建新线程执行任务，execute 方法执行完成；
为什么不推荐使用
CachedThreadPool？
CachedThreadPool使用的是同步队列SynchronousQueue, 允许创建的线程数量为Integer.MAX_VALUE，可能会创建大量线程，从而导致 OOM。
（四）ScheduledThreadPool
ScheduledThreadPool 用来在给定的延迟后运行任务或者定期执行任务。这个在实际项目中基本不会被用到，也不推荐使用。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
}ScheduledThreadPool 是通过 ScheduledThreadPoolExecutor 创建的，使用的DelayedWorkQueue（延迟阻塞队列）作为线程池的任务队列。
DelayedWorkQueue 的内部元素并不是按照放入的时间排序，而是会按照延迟的时间长短对任务进行排序，内部采用的是“堆”的数据结构，可以保证每次出队的任务都是当前队列中执行时间最靠前的。DelayedWorkQueue 添加元素满了之后会自动扩容原来容量的 1/2，即永远不会阻塞，最大扩容可达 Integer.MAX_VALUE，所以最多只能创建核心线程数的线程。
扫一扫
8036
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
