4、 ThreadPoolExecutor 线程池
- 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
- 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
- 提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用线程池，必须对其实现原理了如指掌。
4.1、创建ThreadPoolExecutor、参数、提交任务
// 1
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
}
// 2
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {}
// 3
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {}
- 参数解释：
- corePoolSize(线程池的基本大小)：当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。如果调用了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有基本线程。
- maximumPoolSize(线程池最大数量)：线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是，如果使用了无界的任务队列这个参数就没什么效果。
- keepAliveTime (线程活动保持时间)：线程池的工作线程空闲后，保持存活的时间。所以，如果任务很多，并且每个任务执行的时间比较短，可以调大时间，提高线程的利用率。
- unit (线程活动保持时间的单位)：可选的单位有天(DAYS)、小时(HOURS)、分钟 (MINUTES)、毫秒(MILLISECONDS)、微秒(MICROSECONDS，千分之一毫秒)和纳秒。
- workQueue runnableTaskQueue(任务队列)：用于保存等待执行的任务的阻塞队列。可以选择以下几个阻塞队列。
- ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按FIFO(先进先出)原则对元素进行排序。
- LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。
- SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用 移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于Linked-BlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。
- PriorityBlockingQueue：一个具有优先级的无限阻塞队列。
- handler (饱和策略)：当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。在JDK1.5中Java线程池框架提供了以下4种策略。
- AbortPolicy：直接抛出异常。
- CallerRunsPolicy：只用调用者所在线程来运行任务。
- DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
- DiscardPolicy：不处理，丢弃掉。
- threadFactory 用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字。
- 提交任务
- execute() 方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。
- submit() 方法用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用get(long timeout，TimeUnit unit)方法则会阻塞当前线 程一段时间后立即返回，这时候有可能任务没有执行完。
摘抄自《Java并发编程的艺术》
4.2、线程池的生命周期及其他状态
了解线程池的生命周期对理解线程池的实现原理至关重要。线程池的生命周期通过AtomicInteger类型的变量ctl来维护。
// ctl变量维护线程池的生命周期并提供一些额外方法
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
-
生命周期：
- RUNNING：接受新任务并处理队列中已有的任务。
- SHUTDOWN：不接受新任务，但会处理队列中已有任务。
- STOP：不接受新任务、不处理队列中已有任务，且中断正在运行的任务。
- TIDYING：线程池中所有的线程都已终止，并将workerCount清零。
- TERMINATED：线程池完全停止。
-
生命周期转换：
-
RUNNING -> SHUTDOWN，调用shutdown()方法。 -
(RUNNING or SHUTDOWN) -> STOP，调用shutdownNow()方法。 -
SHUTDOWN -> TIDYING，线程池和任务队列同时为空。 -
STOP -> TIDYING，线程池为空。 -
TIDYING -> TERMINATED，调用terminated()钩子方法。
-
了解了线程池的状态，以及状态之间的转换之后，下面我们着手开始分析线程池的源码。
4.3、以execute方式提交任务
execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。通过分析execute()方法，我们将了解任务提交之后，线程池是如何创建线程、如何将线程池的线程数逐步扩大到maximumPoolSize、以及如何处理队列中的任务。
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// ① 线程池中的线程数小于corePoolSize，创建线程。
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
// ② 线程池中的线程数大于corePoolSize。
// 第二步的逻辑稍有些复杂，分为三个步骤：
// 2.1、若阻塞队列未满，将任务加入阻塞队列，而非创建线程
if (isRunning(c) && workQueue.offer(command)) {
// 因为阻塞队列和线程池使用的不是同一把锁，任务入队之后，
// 线程池的状态可能会发生变化，从而导致任务无法正常执行，所以这里要做一次二次校验
int recheck = ctl.get();
// 2.2、若线程池非运行状态，则将任务移出阻塞队列
//（注意：!isRunning(recheck) = (STOP 或 TIDYING 或 TERMINATED））
// 处于这三种状态之一的线程池即不接受新任务、也不处理队列中的任务
if (!isRunning(recheck) && remove(command))
// 根据RejectedExecutionHandler策略回绝该任务
reject(command);
// 2.3 若线程池中的worker数为0
else if (workerCountOf(recheck) == 0)
// 创建一个任务为null的worker，初看之下较为晦涩难懂。
// 分析：虽然worker数为0，但是阻塞队列不一定为空，
// 而阻塞队列中任务的执行又依赖worker来完成，所以这里加入一个任务为空的worker
// 以便继续执行阻塞队列中的任务
addWorker(null, false);
}
// ③ 执行到此处，线程池中的线程数大于corePoolSize、且队列已满。
// 3.1、若线程池中的线程数小于maximumPoolSize，继续创建线程；
// 3.2、否则根据饱和策略，回绝该任务。
else if (!addWorker(command, false))
reject(command);
}
以上就是通过execute()方法提交任务之后，线程池对任务的接受处理过程。主要分为三种情况：
- 线程池中线程数，小于corePoolSize，创建线程。
- 线程池中线程数，大于corePoolSize，阻塞队列未满，将任务加入阻塞队列。
- 二次判断线程池状态，若非运行状态，回绝；若运行状态，再判断worker数。
- worker数小于0，创建任务为空的worker，以便执行阻塞队列中的任务。
- 线程池中线程数，大于corePoolSize，小于maximumPoolSize，阻塞队列已满，创建线程。
4.3.1、addWorker
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
// 自旋
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// ① 快速检查线程池、阻塞队列的状态，若不满足添加条件，快速返回失败
// 第一个条件：rs >= SHUTDOWN 根据线程池生命周期的定义，若状态大于等于SHUTDOWN不接受新任务
// 第二个条件：rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty() 三者有一个为不成立
// 综合第一个条件：
// 1.1、若rs == SHUTDOWN不成立，rs为STOP、TIDYING、TERMINATED其中之一，不接受新任务、不处理队列任务，返回false；
// 1.2、若firstTask == null不成立，rs为SHUTDOWN，不接受新任务，返回false；
// 1.3、若!workQueue.isEmpty()不成立，rs为SHUTDOWN、且firstTask == null、且队列为空
// 第三个条件较为晦涩，结合前文分析，此条件是为了保证线程池中依然有worker可以处理阻塞队列的任务，
// 若阻塞队列为空，则阻塞队列无任务需要处理，返回false。
if (rs >= SHUTDOWN && !(rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty()))
return false;
// ② 自旋，尝试将worker数加一
for (;;) {
int wc = workerCountOf(c);
if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// ③ 将任务包装成Worker（此步非常重要，下文单独分析）
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// ④ 为防止线程池在获取锁之前关闭，这里要进行二次检查。
// rs < SHUTDOWN 线程池的状态为运行中，可接受新任务、可以处理队列中的任务。
// rs == SHUTDOWN && firstTask == null ？？？ 此处尚不清晰
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
// 将任务添加至worker集合
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
// ④ 开启线程（这一步最终会执行到runWorker()方法，下文单独分析其调用过程）
t.start();
workerStarted = true;
}
}
} finally {
// ⑤ 线程启动失败，回滚
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
addWorker方法是线程池中较为核心的方法之一：
- 状态检查，快速返回失败。如果不了解线程池的状态、线程池运行上下文，则较为晦涩难懂。
- 将任务包装成Worker对象，以便委托worker执行任务。
- 开启线程。开启线程是指开启worker（worker实现了Runnable接口）线程，并通过run方法调用runWorker方法来执行提交的任务。
- worker添加失败，回滚。
4.3.2、 将任务包装成Worker对象
线程池将任务包装成Worker对象，并在其构造方法中通过this将任务指向其本身。由于Worker类继承了Runnable接口，线程启动后，即可通过run()方法调用runWorker()方法来完成任务的执行。
// Worker类部分源码
private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
// 注意：前文addWorker方法中启动的线程即该线程，而该线程即worker本身
final Thread thread;
// 任务
Runnable firstTask;
Worker(Runnable firstTask) {
setState(-1);
this.firstTask = firstTask;
// 注意这里传入的参数为this，即Worker本身
this.thread = getThreadFactory().newThread(this);
}
public void run() {
runWorker(this);
}
}
4.3.3、runWorker
// 委托run()方法来执行runWorker()方法
public void run() {
runWorker(this);
}
// 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 {
// ②
// 2.1、任务不为空，直接执行
// 2.2、任务为空，通过getTask()方法从阻塞队列中获取任务
while (task != null || (task = getTask()) != null) {
w.lock();
if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP)))
&& !wt.isInterrupted())
wt.interrupt();
try {
// 模板方法，任务开始执行之前，可在该方法中做一些额外处理
beforeExecute(wt, task);
Throwable thrown = null;
try {
// ③ 执行任务
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
// 模板方法，任务结束执行之后，可在该方法中做一些额外处理
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
// ④ 处理worker退出
processWorkerExit(w, completedAbruptly);
}
}
- 定义变量completedAbruptly，以标记任务执行过程中，是否抛出异常。
- 获取任务
- 任务不为空，直接执行。
- 否则，通过getTask()方法从队列中获取任务。若当前任务队列中无任务，则阻塞。直至获取到任务或返回null。
- 执行任务。
- 调用processWorkerExit()方法，处理worker退出。
4.3.4、 getTask()
以阻塞或超时（allowCoreThreadTimeOut为true）的方式从队列中获取任务，返回任务或null。比较特殊的是，在该方法有可能导致worker退出：
- 线程池中线程数大于maximumPoolSize（调用setMaximumPoolSize()导致）。
- 线程池状态为STOP。
- 线程池SHUTDOWN且任务队列为空。
- 获取任务超时。
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
// 自旋
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
// 快速判断线程池、任务队列状态
// 1、rs >= STOP 线程池不接受新任务、不处理队列任务，返回null
// 2、rs = SHUTDOWN && workQueue.isEmpty() 队列中无待处理任务，返回null
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// 当allowCoreThreadTimeOut为true或线程池中线程数大于corePoolSize时，可销毁线程
// 1、allowCoreThreadTimeOut：false（默认）：即使核心线程处于空闲状态也不会被销毁；
// 2、allowCoreThreadTimeOut：true： 核心任务超过keepAliveTime还未获取到任务，则销毁。
// 当然是否销毁线程，还需根据后续获取任务的状况判断
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
// 若满足销毁条件，返回null
if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// 获取任务
Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take();
// 如获取到任务，则返回；否则将timedOut标记为true，作为下一轮自旋销毁线程的判断条件
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
小结：代码执行到这里，任务正常执行、通过getTask()方法获取任务并执行两种方式都已分析过。接着分析runWorker方法，还剩下最后一步processWorkerExit()
4.3.5、 processWorkerExit
processWorkerExit执行条件：
- 任务在执行过程中抛出异常
- getTask()方法返回null
private void processWorkerExit(Worker w, boolean completedAbruptly) {
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
completedTaskCount += w.completedTasks;
// 移除worker
workers.remove(w);
} finally {
mainLock.unlock();
}
// 若线程池的状态以及任务队列的状态符合线程池终止的条件，则终止线程池
tryTerminate();
// 尝试终止线程池后，线程池的状态可能发生了变化
// 接下来还要对线程池状态为RUNNING、SHUTDOWN做一些判断
// 防止不合理的清除核心线程、防止清除全部线程而任务队列依然有待执行任务的情况
int c = ctl.get();
if (runStateLessThan(c, STOP)) {
// worker在执行任务时未出异常
if (!completedAbruptly) {
// 定义变量min，记录线程池中可以保留的最小线程数
// 若allowCoreThreadTimeOut为true，则线程池保留最小线程数可以为0；否则为corePoolSize
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
// 核心线程池保留最小线程数为0，则要考虑任务队列是否为空
// 若任务队列不为空，则至少要保留一个线程，以便继续执行任务队列中的任务
if (min == 0 && ! workQueue.isEmpty())
min = 1;
// 若线程池中线程数大于等于min，则直接返回
if (workerCountOf(c) >= min)
return; // replacement not needed
}
// worker在执行任务时出现异常，则向线程池中加入一个任务为空的线程
addWorker(null, false);
}
}
// 尝试终止线程池
final void tryTerminate() {
for (;;) {
int c = ctl.get();
// 检查线程池的状态，以下三种情况，不能终止线程池
// 1、线程池状态为RUNNING
// 2、线程池的状态为TIDYING或TERMINATED
// 3、线程池的状态为SHUTDOWN，但是任务队列中有未处理的任务
if (isRunning(c) || runStateAtLeast(c, TIDYING) || (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
// 检查线程池中线程数是否为0，并中断线程池中空闲的线程
if (workerCountOf(c) != 0) { // Eligible to terminate
interruptIdleWorkers(ONLY_ONE);
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 将线程池的状态设置为TIDYING
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
// 模板方法，可以在该方法中做一些额外的事情
terminated();
} finally {
// 将线程池的状态设置为TERMINATED
ctl.set(ctlOf(TERMINATED, 0));
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
processWorkerExit()方法在尝试终止线程池之后，对线程池、任务队列的状态做了一些判断。再结合completedAbruptly、allowCoreThreadTimeOut属性以确定是否真的销毁线程、是否维护一个执行任务队列的线程。从代码中可以看到，即使是核心线程，也可能被销毁。该段代码虽短，涉及的知识点很多，若分析有不正确的地方，还希望大家可以指正。
分析到此，关于线程池的创建、运行、销毁等核心代码，都以分析完毕。下面再分析一些其他较为重要的代码。
4.4、关闭线程池
关闭线程池有以下两种方式：
- shutdownNow()
- 将线程池状态更改为STOP。
- 中断所有已经启动的线程。
- 返回等待执行的任务列表。
- shutdown()
- 将线程池的状态更改为SHUTDOWN
- 中断所有空闲线程
shutdownNow()和shutdown()虽然同为关闭线程池，但区别还是很大的。在关闭线程池时，如需要执行完等待任务可使用shutdown()，若不考虑，可以使用shutdownNow()。两者大体思路均是通过循环并中断线程来实现，所以任务要尽量可以响应中断，否则有可能导致，虽然线程池关闭了，但是线程依然在运行的情况。
4.4.1、shutdown()
// 关闭线程池
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
// 将线程池的状态更改为SHUTDOWN
advanceRunState(SHUTDOWN);
// 中断所有空闲线程
interruptIdleWorkers();
// ScheduledThreadPoolExecutor 钩子方法
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
// 尝试彻底关闭线程池
tryTerminate();
}
// 中断空闲线程
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 循环所有worker
for (Worker w : workers) {
Thread t = w.thread;
// 若线程未被中断过，且线程空闲
// “空闲” 是指：线程未获取到锁。所以这里尝试去获取锁，一旦能获取成功，则表明该线程确实是空闲线程。
if (!t.isInterrupted() && w.tryLock()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
if (onlyOne)
break;
}
} finally {
mainLock.unlock();
}
}
4.4.2、shutdownNow()
// 关闭线程池
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
// 将线程池的状态更改为STOP
advanceRunState(STOP);
// 中断所有worker
interruptWorkers();
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
// 中断所有已启动线程
private void interruptWorkers() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers)
w.interruptIfStarted();
} finally {
mainLock.unlock();
}
}
4.5、以submit方式提交任务
前文已经分析了以execute()方式提交任务的过程。下面分析一下另一种方式，以submit()方式提交任务。与execute()方法不同，submit()具有返回值。
// 方式一
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;
}
submit()有三种提交任务的方式，可再归纳为两种，一种提交Runnable任务；一种提交Callable任务。submit()较execute()方法只是将任务封装成了FutureTask对象，再调用execute()方法执行任务而已。相对比较简单，不做过多的分析。
接下来介绍一下ThreadPoolExecutor的扩展ScheduledThreadPoolExecutor。
