前言
线程池是并发中一项常用的优化方法,通过对线程的复用,减少线程的创建,降低资源消耗,提高程序响应速度。在Java中我们一般通过Executors提供的工厂方法来创建线程池,但是线程池的最终实现类是ThreadPoolExecutor,下面我们详细分析一下ThreadPoolExecutor的实现。
基本使用
我们首先看下线程池的基本使用。在下面的代码中我们创建一个core size为4,max size为8的线程池,当任务数量超过线程数量的时候,就把任务添加到任务队列中,等线程空闲再从任务队列中获取任务。
import java.util.concurrent.*;
import java.util.stream.IntStream;
public class Application {
static class Worker implements Runnable {
@Override
public void run() {
System.out.println("Thread " + Thread.currentThread().getName() + " start execute command.");
processCommand();
System.out.println("Thread " + Thread.currentThread().getName() + " completed command.");
}
private void processCommand() {
// do something
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(4, 8, 0,
TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(1024), Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy());
IntStream.range(0, 10).forEach(i -> poolExecutor.execute(new Worker()));
poolExecutor.shutdown();
System.out.println("All threads finished");
}
}
概述
在分析线程池的具体实现之前,我们首先看下线程池的具体工作流程,只有先熟悉了流程,才能更好的理解线程池的实现。线程池一般都会关联一个任务队列,用来缓存任务,当线程执行完一个任务之后,会从任务队列中取下一个任务。ThreadPoolExecutor中使用阻塞队列作为任务队列,当任务队列为空时,就会阻塞请求任务的线程。下面是ThreadPoolExecutor整体图示:
下面我们着重看下ThreadPoolExecutor添加任务和关闭线程池的流程。下图是ThreadPoolExecutor添加任务的流程:
我们首先看看添加任务的具体流程:
- 如果线程池中的线程数量少于corePoolSize,那么直接创建一个新线程(无论线程池中是否有空闲线程),然后把该任务分配给新建线程,同是将线程加入到线程池中。
- 如果线程池的线程数量大于等于corePoolSize,那就将任务添加到任务队列中。
- 如果任务队列已经饱和(对于有边界的任务队列),那么就检查线程池中的线程数量是否少于maximumPoolSize,如果少于,就创建新线程,将当前任务分配给新线程,同时将线程加入到线程池中,否则就对该任务执行reject策略。
在ThreadPoolExecutor中通过两个量来控制线程池的大小:corePoolSize和maximumPoolSize。corePoolSize表示正常状态下线程池中应该持有的存活线程数量,maximumPoolSize表示线程池可以持有的最大线程数量。当线程池中的线程数量不超过corePoolSize时,位于线程池中的线程被看作core线程,默认情况下,线程池不对core线程进行超时回收控制,也就是默认情况下core线程会一直存活在线程池中,直到线程池被关闭(这里忽略线程异常关闭的情况)。当线程池中的线程数量超过corePoolSize时,额外的线程被看作非core线程,线程池会对这部分线程进行超时控制,当线程空闲keepAliveTime(时间单位是参数unit)之后会销毁该线程。非core线程主要用来处理某段时间并发任务特别多的情况,即之前的线程配置无法及时处理那么多的任务量,需要额外的线程来帮忙。而当这批任务处理完成之后,额外的线程就有些多余了(线程越多占用的资源越多),因此需要及时销毁。
ThreadPoolExecutor定义线程数量上限是2^29 - 1 = 536870911(后面会讲到为什么是这个数),同时用户可以自定义最大线程数量,ThreadPoolExecutor处理时会选这两者之间的较小值。当线程池的线程数量等于maximumPoolSize时,说明线程池已经饱和了,此时对于新来的任务就要执行reject策略,JDK中定义了四种拒绝策略:
- AbortPolicy:直接抛出异常,默认策略
- CallerRunsPolicy:使用调用者所在的线程执行任务
- DiscardOldestPolicy:丢弃当前任务队列中最前面的任务,并执行execute方法添加新任务
- DiscardPolicy:直接丢弃任务
下面再来看一下线程池的关闭,线程池的关闭分为两种:平缓关闭(shutdown)和立即关闭(shutdownNow)。当调用shutdown方法之后,线程池不再接受新的任务,此时仍然会将任务队列中的已有任务执行完毕。而调用shutdownNow方法之后,线程池不仅不再接收新的任务,也不会再执行任务队列中的剩余任务,同时通过中断的方式尝试停止正在执行任务的线程(我们知道对于中断,线程可能响应也可能不响应,所以不能保证一定停止线程)。
具体实现
下面我们从源码的角度分析一下ThreadPoolExecutor的实现:
Worker
ThreadPoolExecutor中的每个线程都关联一个Worker对象,而ThreadPool里实际上保存的就是线程关联的Worker对象。Worker类对线程进行包装,它除了保存关联线程的信息,还保存一些其他的信息,如线程创建时分配的首任务,线程已完成的任务数量。Worker实现了Runnable接口,创建线程时往Thread类传的参数就是该对象,所以线程创建后会执行Worker的run方法。同时Worker类还继承了AbstractQueuedSynchronizer,使自身成为一个不可重入的互斥锁(以下称为Worker锁,注意Worker锁是不可重入的,也就是说该锁只能被一个线程获取一次),因此每个线程实际上也关联了一个互斥锁。当线程执行任务时,需要首先获得关联的Worker锁,执行完任务之后再释放该锁。Worker锁的主要作用是为了平缓关闭线程池时,判断线程是否空闲(根据是否能获得Worker锁)。下面是Worker类的实现:
private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
/**
* This class will never be serialized, but we provide a
* serialVersionUID to suppress a javac warning.
*/
private static final long serialVersionUID = 6138294804551838833L;
/** Thread this worker is running in. Null if factory fails.
* 当前Worker关联的线程
*/
final Thread thread;
/** Initial task to run. Possibly null.
* 线程创建后的初始任务
*/
Runnable firstTask;
/** Per-thread task counter
* 线程完成的任务数量
*/
volatile long completedTasks;
/**
* Creates with given first task and thread from ThreadFactory.
* @param firstTask the first task (null if none)
*/
Worker(Runnable firstTask) {
// 只有state为0,线程才能获取到Worker锁,这里将state设为-1,
// 表明任何线程都无法获取锁,在shutdown方法中,如果要中断线程,需要首先获得线程
// 关联的Worker锁,而shutdownNow中断线程之前,会首先判断state是否大于等于0
// 所以这里将state设置为-1,可以防止当前线程被中断
// 在runWorker方法中会在执行任务之前调用unlock方法来把Worker锁state置0,允许中断。
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
/** Delegates main run loop to outer runWorker */
public void run() {
runWorker(this);
}
// Lock methods
//
// The value 0 represents the unlocked state.
// The value 1 represents the locked state.
// state为1的时候表示持有锁,state为0的时候表示未持有锁
protected boolean isHeldExclusively() {
return getState() != 0;
}
// 可以看到Worker锁并不是一个可重入锁
protected boolean tryAcquire(int unused) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
public void lock() { acquire(1); }
public boolean tryLock() { return tryAcquire(1); }
public void unlock() { release(1); }
public boolean isLocked() { return isHeldExclusively(); }
// 只要线程启动了,就中断线程,用于shutdownNow方法
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
我们看到在Worker的构造函数中将state设为-1,注释里给出的解释是:禁止中断直到执行了runWorker方法。其实这里包含了三个问题:
- 为什么要等到执行了runWorker方法?
- 怎么禁止中断?
- 如果某个线程state为-1时,线程池shutdownNow方法被调用会这么处理该方法?
对于问题1,我们知道中断是针对运行的线程,当线程创建之后只有调用了start方法,线程才真正运行,而start方法的调用是在runWorker方法中的,也就是只有执行了runWorker方法,线程才真正启动。
对于问题2,这个主要是针对shutdown方法和shutdownNow方法的。在shutdown方法中,中断线程之前会首先尝试获取线程的Worker锁,只有获得了Worker锁才对线程进行中断。而获得Worker锁的前提是Worker锁的state变量为0,当state设为-1时候,任何线程都无法获取该锁,那么也就无法对线程执行中断操作。而在shutdownNow方法中,会调用Worker的interruptIfStarted方法来中断线程,而interruptIfStarted方法只有再state>=0时才会中断线程,所以将state设为-1可以防止线程被提前中断。当执行runWorker方法时,会为传入的Worker对象执行unlock操作(也就是讲state置为0),使Worker对象的state变为0,这样就使线程处于可被中断的状态了。
对于问题3,在之后在进行解释。
状态变量
在ThreadPoolExecutor中定义了一个AtomicInteger类型的变量ctl(ctl就是control的缩写),用来保存线程池的状态和线程数量信息。下面是该变量的定义:
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
ctl变量使用低29位保存线程的数量(这也就是线程池最大线程数量为2^29-1的原因),高3位保存线程池的状态。为了提取出这两个信息,ThreadPoolExecutor定义了一个低29位全是1的变量CAPACITY,通过和CAPACITY进行&运算可以获得线程的数量,通过和~CAPACITY进行&运算可以获得线程池的状态,下面是程序中的实现:
// 存储线程数量的 bit 位数,这里是 29
private static final int COUNT_BITS = Integer.SIZE - 3;
// 用于提取线程池的运行状态以及线程数量,低 29 位全为 1,高 3 位为0
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// 获得线程池的运行状态
private static int runStateOf(int c) {
return c & ~CAPACITY;
}
// 获得线程的数量
private static int workerCountOf(int c) {
return c & CAPACITY;
}
// 拼接run state和worker count为一个integer
private static int ctlOf(int rs, int wc) { return rs | wc; }
ThreadPoolExecutor中为线程池定义了五种状态:
- RUNNING:正常状态,接受新的任务,并处理任务队列中的任务
- SHUTDOWN:不接受新的任务,但是处理已经在任务队列中的任务
- STOP:不接受新的任务,也不处理已经在任务队列中的任务,同时会尝试停止正在执行任务的线程
- TIDYING:线程池和任务队列都为空,该状态下线程会执行terminated()方法
- TERMINATED:terminated()方法执行完毕
下面是JDK中关于5个变量的定义:
// 11100000000000000000000000000000 -536870912
private static final int RUNNING = -1 << COUNT_BITS;
// 00000000000000000000000000000000 0
private static final int SHUTDOWN = 0 << COUNT_BITS;
// 00100000000000000000000000000000 536870912
private static final int STOP = 1 << COUNT_BITS;
// 01000000000000000000000000000000 1073741824
private static final int TIDYING = 2 << COUNT_BITS;
// 01100000000000000000000000000000 1610612736
private static final int TERMINATED = 3 << COUNT_BITS;
下面是各状态之间的转换:
- RUNNING -> SHUTDOWN:调用了shutdown()方法
- RUNNING or SHUTDOWN -> STOP :调用了shutdownNow()方法
- SHUTDOWN -> TIDYING:线程池和任务队列都为空
- STOP -> TIDYING:线程池为空
- TIDYING -> TERMINATED:执行完terminated方法
添加任务
通过execute或者submit方法都可以向线程池中添加一个任务,submit会返回一个Future对象来获取线程的返回值,下面是submit方法的实现:
public Future <?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture <Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
可以看到submit只是将Runnable对象包装一下,最终还是调用了execute方法。下面我们看下execute方法的实现:
public void execute(Runnable command) {
// command 不能为 null
if (command == null)
throw new NullPointerException();
// 获取线程池中的control信息,control信息中的前三个bit是线程池运行状态,后29个bit是线程池worker count
int c = ctl.get();
// 线程数量少于 corePoolSize,会创建一个新的线程执行该任务
if (workerCountOf(c) < corePoolSize) {
// true 表示当前添加的线程为核心线程
if (addWorker(command, true))
return;
// 如果程序运行到这里说明,线程池状态不允许添加新任务或者是线程池的核心线程已满
c = ctl.get();
}
// 线程数量大于等于 corePoolSize,首先尝试将任务添加到任务队列
// workQueue.offer 会将任务添加到队列尾部
if (isRunning(c) && workQueue.offer(command)) {
// 重新检查状态
int recheck = ctl.get();
// 如果发现当前线程池不是处于 Running 状态,就移除之前的任务
// 移除任务过程有锁保护
if (!isRunning(recheck) && remove(command)) {
reject(command);
} else if (workerCountOf(recheck) == 0) {
// workerCountOf 用来统计当前的工作线程(所谓工作线程数量就是当前线程池中存在多少个线程)数量,程序执行到这里,有下面两种可能:
// 1. 当前线程池处于 Running 状态,但是工作线程数量为 0,
// 需要创建新的线程
// 2. 移除任务失败,但是工作线程数量为 0,
// 需要创建新的线程来完成移除失败的任务
//
// 因为前面对任务做了判断,所以正常情况下向 addWorker 里传入的任务
// 不可能为 null,这里传入 null 是告诉 addWorker 需要创建新的线程,
// 在 addWorker 里对 null 有专门的处理逻辑
addWorker(null, false);
}
// 下面的 else 说明线程池不是 Running 状态或者任务队列满而创建新线程运行任务
} else if (!addWorker(command, false)) {
// 这里说明线程池不是 Running 状态或者线程池饱和了
reject(command);
}
}
public boolean remove(Runnable task) {
boolean removed = workQueue.remove(task);
tryTerminate(); // In case SHUTDOWN and now empty
return removed;
}
在前面我们提到了线程池添加任务的流程,这是在重述一遍:
- 如果线程池的线程数量少于corePoolSize,则新建一个线程,执行当前任务,并将该任务添加到线程池
- 如果线程池的线程数量大于等于corePoolSize,则首先将任务添加到任务队列
- 如果任务队列已满,如果目前线程池线程未达到maximumPoolSize则继续创建线程,否则调用reject策略处理该任务
addWorker方法会创建并启动线程,当线程池不处于Running状态并且传入的任务不为null,addWorker就无法成功创建线程。下面是addWorker方法的具体实现:
private boolean addWorker(Runnable firstTask, boolean core) {
// retry 类似于 goto,continue retry 跳转到 retry 定义,
// 而 break retry 跳出 retry
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 我们在下面详细讲解该条件
if (rs >= SHUTDOWN && !(rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
// 线程数量大于系统规定的最大线程数或者大于 corePoolSize/maximumPoolSize
// 表明线程池中无法添加新的线程,这里 wc >= CAPACITY 为了防止 corePoolSize
// 或者 maximumPoolSize 大于CAPACITY
if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize)) {
return false;
}
// 使用 CAS 方式将线程数量增加,如果成功就跳出 retry
if (compareAndIncrementWorkerCount(c)) {
break retry;
}
c = ctl.get(); // Re-read ctl
// 如果线程池运行状态发生了改变就从 retry(外层循环)处重新开始,
if (runStateOf(c) != rs)
continue retry;
// 程序执行到这里说 CAS 没有成功,那么就再次执行 CAS
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// 创建 work
w = new Worker(firstTask);
final Thread t = w.thread;
// t != null 说明线程创建成功了
if (t != null) {
// 程序用一个 HashSet 存储线程,而 HashSet 不是线程的安全的,
// 所以将线程加入 HashSet 的过程需要加锁。
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 rs = runStateOf(ctl.get());
// 1. rs < SHUTDOWN 说明程序在运行状态
// 2. rs == SHUTDOWN 说明当前线程处于平缓关闭状态,而 firstTask == null
// 说明当前创建的线程是为了处理任务队列中剩余的任务(故意传入 null)
if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) {
// 线程是存活状态说明线程提前开始了。
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
// 启动线程
t.start();
workerStarted = true;
}
}
} finally {
if (!workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
这里我们着重看下返回false的条件:
if (rs >= SHUTDOWN && !(rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty()))
// 等价于
if(rs >= SHUTDOWN && (rs != SHUTDOWN || firstTask != null || workQueue.isEmpty()))
// 等价于
if((rs >= SHUTDOWN && rs != SHUTDOWN) || (rs == SHUTDOWN && firstTask != null) || (rs == SHUTDOWN && firstTask == null && workQueue.isEmpty()))
我们依次看下上面的条件:
- rs >= SHUTDOWN && rs != SHUTDOWN:说明线程池处于STOP,TIDYING或者TERMINATED状态下,处于这三种状态说明线程池处理完了所有任务或者不在执行剩余的任务,可以直接返回
- rs == SHUTDOWN && firstTask != null:在execute方法中,我们知道如果传入null,说明创建线程是为了执行队列中的剩余的任务(此时线程池中没有工作线程),这时就不应该返回。而如果firstTask!=null,说明不是为了处理队列中的剩余的任务,可以返回
- rs == SHUTDOWN && firstTask == null && workQueue.isEmpty():说明任务队列中的任务已经全部执行完成了,无需创建新的线程,可以返回
当创建线程并且成功启动后,会执行Worker的run方法,而run方法中又会调用ThreadPoolExecutor的runWorker方法,并且将自身作为参数传进去了,下面是runWorker方法的实现:
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
// 这里将 Worker 中的 state 设为 0,以便其他线程可以获得锁
// 从而可以中断当前线程
w.unlock(); // allow interrupts
// 用来标记线程是正常退出循环还是异常退出
boolean completedAbruptly = true;
try {
// 如果任务不为空,说明是刚创建线程,如果任务为空,则从队列中取任务
// 如果队列没有任务,线程就会阻塞在这里
while (task != null || (task = getTask()) != null) {
// 获取Worker锁
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);
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;
// 因为 runnable 方法不能抛出 checkedException ,所以这里
// 将异常包装成 Error 抛出
throw new Error(x);
} finally {
// 任务执行完之后做一些处理,默认空函数
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
上面的代码中,我们把第一个if判断拿出来分析一下:
private static boolean runStateAtLeast(int c, int s) {
return c >= s;
}
if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP)))
&& !wt.isInterrupted())
wt.interrupt();
这段if代码块的功能有两个:
- 如果当前线程池的状态小于STOP ,也就是处于RUNNING或者SHUTDOWN状态,要保证线程池中的线程处于非中断状态
- 如果当前线程池的状态大于等于STOP,也就是处于STOP,TIDYING或者TERMINATED状态,要保证线程池中的线程处于中断状态
上面的if判断中的括号比较多,我们先将其分为两个大条件:
- runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP)) &&
- !wt.isInterrupted()
我们先看第二个条件:!wt.isInterrupted(),该条件说明当前线程没有被中断,只有在线程没有被中断的前提下,才有可能对线程执行中断操作。
然后我们将第一个大条件再进行拆分,可以分为下面两个条件:
- runStateAtLeast(ctl.get(), STOP) ||
- Thread.interrupted() && runStateAtLeast(ctl.get(), STOP)
我们先看第一个条件,该条件说明线程处于STOP以及之后的状态,线程应该被中断。如果该条件不成立,说明当前线程不应该被中断,那么会调用Thread.interrupted()方法,该方法会返回线程的中断状态,然后重置线程中断状态,如果中断状态为false,那么就可以跳出if代码块了,但是如果中断状态为true,说明线程被中断过了,此时我们就要判断线程中断是不是由shutdownNow方法(并发调用,该方法会中断线程池的线程,并修改线程池状态为STOP,后面会讲到)造成的,所以我们需要再检查一下线程的状态,如果发现当前线程池已经变成STOP或者之后的状态,说明确实是由shutdownNow方法造成的,需要重新对线程进行中断,如果不是那就不需要再中断线程了。
我们看到runWorker方法里会一直循环调用getTask来获取任务,下面来看getTask的实现:
/**
* getTask 返回 null,说明当前线程需要被回收了
*/
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// rs >= SHUTDOWN 说明当前线程池至少处于待关闭状态,不再接受新的任务
// 1. rs >= STOP: 说明不需要在再处理任务了(即便有任务)
// 2. workQueue.isEmpty(): 说明任务队列中剩余的任务已经处理完了
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
// timed 用于判断是否需要对线程进行超时控制
// 1. allowCoreThreadTimeOut: 为 true 说明可以对 core 线程进行超时控制,当然对于非core线程也是超时控制的。
// 2. wc > corePoolSize: 说明线程池中有非 core 线程
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
// 1. wc > maximumPoolSize || (timed && timedOut)
// 线程数量大于 maximumPoolSize 值了 或者 允许超时控制并且超时了
// 2. wc > 1 || workQueue.isEmpty()
// 线程中活动线程的数量大于 1,而Worker上次等待任务超时,说明现在任务并不是很多回收一个线程 或者 任务队列为空(不需要在留线程执行剩余的任务了)
// 如果上面 1 和 2 都成立,就使用 CAS 将线程数量减 1 并返回 null 回收当前线程
// 如果 CAS 失败了就重试
if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// 如果允许超时控制,则执行 poll 方法,该方法响应超时,当 keepAliveTime 时间内
// 仍然没有获取到任务,就返回 null。take 方法不响应超时操作,当获取不到任务时会一直等待。
// 另外不管 poll 还是 take 方法都会响应中断,如果没有新的任务添加到队列中
// 会直接抛出 InterruptedException
// 对于core线程,只会判断一次任务队列中是否还有任务,所以可能会导致在调用shutdown方法之后
// core线程错过了shutdown信号,进入阻塞状态,为了解决这个问题Doug Lea在所有可能退出线程池的地方调用
// tryTerminate方法解决
Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take();
if (r != null)
return r;
// 执行到这里说明超时了
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
当getTask返回null的时候说明线程需要被回收了,我们总结一下在getTask中返回null的情况:
- 线程池总工作线程数量大于maximumPoolSize(一般是由于我们调用setMaximumPoolSize方法重新设置了maximumPoolSize)
- 线程池状态大于等于STOP
- 线程池处于SHUTDOWN状态,并且任务队列为空
- 线程在等待任务队列时超时,并且工作线程数大于1
我们将runWorker和getTask结合起来看,整个流程就比较明朗了:
- 通过while循环不断的从任务队列中获取任务,如果当前任务队列中没有任务,就阻塞线程。如果getTask返回null,表明当前线程应该被回收,执行回收线程的逻辑。
- 如果成功获取任务,首先判断线程池的状态,根据线程池状态设置的当前线程的中断状态
- 在执行任务之前做一些预处理(用户实现)
- 执行任务
- 在执行任务之后做一些收尾处理(用户实现)
上面两个方法是整个线程池中比较核心的部分,在这两个方法中,完成了任务获取与阻塞线程的工作。下面是线程提交->处理任务->回收的流程图:
下面我们再看下processWorkerExit方法,该方法主要用来完成线程的回收工作:
private void processWorkerExit(Worker w, boolean completedAbruptly) {
// 如果 completedAbruptly 为 true,说明线程是由于抛出异常而跳出循环的,
// 没有正确执行 getTask 中减少线程数量的逻辑,所以这里要将线程数量减一
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 更新已完成的任务数量,并移除工作线程
completedTaskCount += w.completedTasks;
workers.remove(w);
} finally {
mainLock.unlock();
}
// 尝试终止线程池
tryTerminate();
int c = ctl.get();
// 如果线程状态是 SHUTDOWN 或者 RUNNING,需要保证线程中的最少线程数量
// 1. 如果线程是由于抛出异常而结束的,直接添加一个线程
// 2. 如果线程是正常结束的
// * 如果允许对 core 线程进行超时控制,并且任务队列中有任务
// 则保证线程数量大于等于 1
// * 如果不允许对 core 进行超时控制,则保证线程数量大于等于 corePoolSize
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && !workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
addWorker(null, false);
}
}
我们可以看到线程池中至少会有一个线程存在,可能有人会发问为什么在线程池执行完成所有的任务之后调用ThreadPoolExecutor的getActiveCount方法返回的是0呢?我们来看看getActiveCount方法的源码:
public int getActiveCount() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
int n = 0;
for (Worker w : workers)
if (w.isLocked())
++n;
return n;
} finally {
mainLock.unlock();
}
}
可以看到getActiveCount方法返回的其实是workers里所有持有Worker锁的的Worker数量,而我们从addWorker方法中可以看到,Worker对象是在Worker执行之前添加到workers里的,所以getActiveCount返回的是正在执行任务的线程数,而不是线程池中的存在的线程数。
我们看到processExit中调用了tryTerminate方法,该方法主要用来终止线程池。如果线程池满足终止条件,首先将线程池状态设置为TIDYING,然后执行terminated方法,最后将线程池状态设为TERMINATED。在shutdown和shutdownNow方法以及remove方法中都会调用该方法。
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,此时线程池状态为SHUTDOWN且任务队列也为空或者线程池状态为STOP
if (workerCountOf(c) != 0) { // Eligible to terminate
// 如果工作线程数量不为 0,就尝试中断正在线程池中的空闲线程
// ONLY_ONE 说明只尝试中断线程池中第一个线程,如果没有空闲的工作线程,则不中断任何线程
interruptIdleWorkers(ONLY_ONE);
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 将线程状态设为 TIDYING,如果设置不成功说明线程池的状态发生了变化,需要重试
// 这里线程池状态从 TIDYING 到 TERMINATED 状态转换是原子的
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
// 执行 terminated 方法(默认空方法)
terminated();
} finally {
// 将线程状态设为 TERMINATED
ctl.set(ctlOf(TERMINATED, 0));
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
在tryTerminate方法中,如果满足下面两个条件,就将线程池状态设为TIDYING:
- 线程池状态为SHUTDOWN并且线程池和任务队列均为空
- 线程池状态为STOP并且线程池为空
如果线程池处于SHUTDOWN或者STOP状态,但是工作线程不为空,那么tryTerminate会尝试中断线程池中的一个线程,这样做主要是为了防止shutdown的中断信号丢失(我们在shutdown方法处再详细讨论)。下面看下interruptIdleWorkers方法,该方法主要中断空闲线程:
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w: workers) {
Thread t = w.thread;
// 首先看当前线程是否已经中断,如果没有中断,就看线程是否处于空闲状态
// 如果能获得线程关联的 Worker 锁,说明线程处于空闲状态,可以中断
// 否则说明线程不能中断
if (!t.isInterrupted() && w.tryLock()) {
try {
t.interrupt();
} catch (SecurityException ignore) {} finally {
w.unlock();
}
}
// 如果 onlyOne 为 true,只尝试中断第一个线程
if (onlyOne)
break;
}
} finally {
mainLock.unlock();
}
}
关闭线程池
通过shutdown和shutdownNow方法我们可以关闭线程池,关于两者的区别在前面已经提到过了,这里不再赘述。我们首先看下shutdown方法:
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 检查当前线程是否有关闭线程池的权限
checkShutdownAccess();
// 将线程池状态设为 SHUTDOWN
advanceRunState(SHUTDOWN);
// 中断线程,这里最终调用 interruptIdleWorkers(false);
interruptIdleWorkers();
// hook 方法,默认为空,让用户在线程池关闭时可以做一些操作
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
tryTerminate();
}
在前面我们知道 interruptIdleWorkers 会先检查线程是否是空闲状态,如果发现线程不是空闲状态,才会中断线程。而这时中断线程的主要目的是让在任务队列中阻塞的线程醒过来。考虑下面的情况,如果执行 interruptIdleWorkers 时,core线程正在运行,所以没有被中断,但是线程执行完任务之后,继续进入getTask查询任务队列中是否还有其他任务,如果因为某种原因该core线程却并没有获取到任务(比如说多个core线程争抢同一个任务,最终只有一个core线程成功获取到任务,其他core线程都进入到阻塞状态),而任务队列恰好为空,线程就会处于阻塞状态,而此时 shutdown 已经执行完 interruptIdleWorkers 操作了(即线程错过了 shutdown 的中断信号),如果没有额外操作,线程会一直处于阻塞状态。所以为了防止这种情况,在 tryTerminate() 中也增加了 interruptIdleWorkers 操作,主要就是为了弥补 shutdown 中丢失的信号。
最后我们再看下shutdownNow方法:
public List < Runnable > shutdownNow() {
List < Runnable > tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 检查线程是否具有关闭线程池的权限
checkShutdownAccess();
// 更改线程状态
advanceRunState(STOP);
// 中断线程
interruptWorkers();
// 清除任务队列,并将任务返回
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
然后我们看下 interruptWorkers 方法:
private void interruptWorkers() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 不管线程是否空闲都执行中断
for (Worker w: workers)
w.interruptIfStarted();
} finally {
mainLock.unlock();
}
}
从上面的代码中我们可以看到在 interruptWorkers 方法中,只要线程开始了,就对线程执行中断,所以 shutdownNow 的中断信号不会丢失。最后我们再看下 drainQueue 方法,该方法主要作用是清空任务队列,并将队列中剩余的任务返回。
private List <Runnable> drainQueue() {
BlockingQueue <Runnable> q = workQueue;
ArrayList <Runnable> taskList = new ArrayList < Runnable > ();
// 该方法会将阻塞队列中的所有项添加到 taskList 中
// 然后清空任务队列,该方法是线程安全的
q.drainTo(taskList);
if (!q.isEmpty()) {
// 将 List 转换为 数组,传入的 Runnable[0] 用来说明是转为 Runnable 数组
for (Runnable r: q.toArray(new Runnable[0])) {
if (q.remove(r))
taskList.add(r);
}
}
return taskList;
}
参考文章
本文章大部分内容来源于ThreadPoolExecutor,只做了小部分的更改。