提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
前言
在Java语言中，虽然创建并启动一个线程非常方便，但是由于创建线程需要占用一定的操作系统资源，在高并发的情况下，频繁的创建和销毁线程会大量消耗CPU和内存资源，对程序性能造成很大的影响。为了避免这一问题，Java给我们提供了线程池。
线程池是一种基于池化技术思想来管理线程的工具。在线程池中维护了多个线程，由线程池统一的管理调配线程来执行任务。通过线程复用，减少了频繁创建和销毁线程的开销。
一、线程池的优点 ？
- 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
- 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
- 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
👆出自《Java 并发编程的艺术》
二、线程池的生命周期
线程池从诞生到死亡，中间会经历RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED五个生命周期状态。
- RUNNING：接收新的任务并对任务队列里的任务进行处理；
- SHUTDOWN：不再接收新的任务，但是会对任务队列中的任务进行处理；
- STOP：不接收新任务，也不再对任务队列中的任务进行处理，并中断正在处理的任务；
- TIDYING：所有任务都已终止，线程数为0，在转向TIDYING状态的过程中，线程会执行terminated()钩子方法，钩子方法是指在本类中是空方法，而在子类中进行具体实现的方法
- TERMINATED：terminated()方法执行结束后会进入这一状态，表示线程池已关闭
代码里使用一个 int 值来表示线程池的状态和工作线程数，Java 中一个 int 占 4 个字节 32 位，高 3 位表示线程的状态低 29 位表示工作线程的数量
// 高 3 位为线程池状态低 29 位为线程工作线程的个数
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int COUNT_MASK = (1 << COUNT_BITS) - 1;
// 线程池状态，值越来越大，线程池的状态只会从 RUNNING -> TERMINATED 不会反向变化
// 用于根据这些常量值比较线程处于什么状态
// RUNNING: 十进制:-536870912 二进制:11100000000000000000000000000000
private static final int RUNNING = -1 << COUNT_BITS;
// SHUTDOWN: 十进制:0 二进制:0
private static final int SHUTDOWN = 0 << COUNT_BITS;
// STOP: 十进制:536870912 二进制:00100000000000000000000000000000
private static final int STOP = 1 << COUNT_BITS;
// TIDYING: 十进制:1073741824 二进制:01000000000000000000000000000000
private static final int TIDYING = 2 << COUNT_BITS;
// TERMINATED: 十进制:1610612736 二进制:01100000000000000000000000000000
private static final int TERMINATED = 3 << COUNT_BITS;
// 线程池状态
private static int runStateOf(int c) { return c & ~COUNT_MASK; }
// 线程池工作线程的个数
private static int workerCountOf(int c) { return c & COUNT_MASK; }
private static int ctlOf(int rs, int wc) { return rs | wc; }
三、构造参数
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 空闲线程的存活时间
- unit 空闲线程存活时间的单位
- workQueue 阻塞队列
- threadFactory 线程工厂
- handler 拒绝策略
线程池的工作机制大致是当添加一个任务时，如果线程池中的工作线程个数小于核心线程数则创建核心线程执行任务，如果超出核心线程数则加入阻塞队列，如果阻塞队列也已经满了则创建非核心线程执行任务，最后如果线程池中的工作线程超出最大线程数则执行拒绝策略，如果有线程执行完任务再去阻塞队列中去取任务执行，如果超出空闲线程的存活时间还没有取到任务则从线程池中移除线程，整个流程就依赖于上面的这些参数。
线程池的拒绝策略表现为一个接口 RejectedExecutionHandler 默认的实现有 4 种
- AbortPolicy：丢弃任务并抛出 RejectedExecutionException 异常
- DiscardPolicy：也是丢弃任务，但是不抛出异常。
- DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
- CallerRunsPolicy：由调用线程直接执行该任务
如果不设置默认是 AbortPolicy 抛出异常
四、源码分析
在 Java 中线程池通常指 ThreadPoolExecutor 下面就来分析一下它的源码
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 如果工作线程的个数小于核心线程数
if (workerCountOf(c) < corePoolSize) {
// 创建核心线程去执行任务
if (addWorker(command, true))
return;
c = ctl.get();
}
// 将任务加入阻塞队列
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
// 如果线程池状态变化则从阻塞队列中移除
if (! isRunning(recheck) && remove(command))
// 执行拒绝策略
reject(command);
else if (workerCountOf(recheck) == 0)
// 如果工作线程数为 0 则创建线程去获取任务执行
addWorker(null, false);
}
// 加入阻塞队列失败则创建非核心线程去执行任务，加入失败则执行拒绝策略
else if (!addWorker(command, false))
reject(command);
}
这部分代码就是对上面说的线程池的工作流程的表现，再看一下 addWorkder 的代码
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (int c = ctl.get();;) {
// case1：线程池是 STOP 之后的状态
// case2：线程池是 SHUTDOWN 状态并且是加入新的任务（SHUTDOWN 状态不接受新任务）
// case3：线程池是 SHUTDOWN 状态并且阻塞队列为空
if (runStateAtLeast(c, SHUTDOWN)
&& (runStateAtLeast(c, STOP)
|| firstTask != null
|| workQueue.isEmpty()))
return false;
for (;;) {
// 如果工作线程数超出最大线程数
if (workerCountOf(c)
>= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
return false;
// 增加工作线程个数
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
// 如果 CAS 操作失败则重新循环
if (runStateAtLeast(c, SHUTDOWN))
continue retry;
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int c = ctl.get();
// case1：线程池处于 RUNNING 状态
// case2：线程池处于 SHUTDOWN 状态并且不是执行新任务
if (isRunning(c) ||
(runStateLessThan(c, STOP) && firstTask == null)) {
if (t.getState() != Thread.State.NEW)
throw new IllegalThreadStateException();
workers.add(w);
workerAdded = true;
int s = workers.size();
// 记录线程池最大线程数量
if (s > largestPoolSize)
largestPoolSize = s;
}
} finally {
mainLock.unlock();
}
// 启动线程
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
// 如果启动线程失败则移除线程减少线程池线程数量并尝试终结线程池
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
在线程池中线程以 Worker 的形式存在，它实现了 Runnable 接口 run 方法中直接调用了 runWorker 方法
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
// 如果 firstTask 不为空或者从阻塞队列中取到了任务
while (task != null || (task = getTask()) != null) {
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
// 钩子方法用于子类重写
beforeExecute(wt, task);
try {
// 执行任务
task.run();
afterExecute(task, null);
} catch (Throwable ex) {
afterExecute(task, ex);
throw ex;
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
// 如果取不到任务移除线程，尝试终结线程池
processWorkerExit(w, completedAbruptly);
}
}
主要就是获取任务执行任务，获取任务的逻辑在 getTask 中
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
// case1：线程池处于 STOP 或者之后的状态
// case2：线程池处于 SHUTDOWN 并且阻塞队列为空
if (runStateAtLeast(c, SHUTDOWN)
&& (runStateAtLeast(c, STOP) || workQueue.isEmpty())) {
// 工作线程的个数减 1
decrementWorkerCount();
return null;
}
// 工作线层的个数
int wc = workerCountOf(c);
// 如果允许核心线程超时或者线程池工作线程数量超出核心线程数
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// poll 超时返回 null 表示在指定的时间内没有获取到任务
// take 没有任务时一直阻塞
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
在获取任务时如果线程可以超时则使用 poll 获取任务，否则使用 take 获取任务，这里也是线程池的非核心线程超出空闲时间后会销毁的原因（可以通过设置 allowCoreThreadTimeOut 为 true 来让核心线程也可以超时），另外这里也可以看出线程池里的线程是不区分核心线程和非核心线程数的，只是当 allowCoreThreadTimeOut 为 false 的时候线程池里的线程即使空闲也会保留核心线程数个线程
除了execute 线程池还提供了另一个方法 submit 来提交一个任务，它们的区别是 submit 除了可以提交 Runnable 类型的任务还可以提交 Callable 类型的任务并且方法的返回值都是 java.util.concurrent.Future 可以用于取消任务或者阻塞获取任务的返回值
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Runnable task, T result) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task, result);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
五、线程池的关闭
线程池提供了 shutdown() shutdownNow() 和awaitTermination() 三个方法来关闭线程池，它们的区别是
- shutdown 调用后线程池进入 SHUTDOWN 状态不再接受新任务但是会继续执行阻塞队列里的任务，方法返回值为空
- shutdownNow 调用后线程池进入 STOP 状态不再接受新任务并且会尝试停止工作中的线程，方法返回值为没有执行的任务
- awaitTermination 调用后当前线程阻塞指定时间，返回值是 boolean 类型，如果在指定的时间内线程池已经变成 TERMINATED 状态返回 true 否则超时返回 false
六、ScheduledThreadPoolExecutor
ScheduledThreadPoolExecutor 是 ThreadPoolExecutor 的子类用于执行周期性的任务，主要流程
- 线程 1 从 DelayQueue 中获取已到期的 ScheduledFutureTask（DelayQueue.take()）。到期任务是指 ScheduledFutureTask的 time 大于等于当前系统的时间；
- 线程 1 执行这个 ScheduledFutureTask；
- 线程 1 修改 ScheduledFutureTask 的 time 变量为下次将要被执行的时间；
- 线程 1 把这个修改 time 之后的 ScheduledFutureTask 放回 DelayQueue 中（DelayQueue.add())。
参考
关闭线程池的正确姿势，shutdown(), shutdownNow()和awaitTermination() 该怎么用？
JavaGuide
Java并发系列终结篇：彻底搞懂Java线程池的工作原理
线程池是怎样工作的
深入浅出Java线程池：理论篇
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
