1. 线程池状态
线程池有五种状态,定义在ThreadPoolExecutor中。
// runState is stored in the high-order bits
//可以接受新的任务,也可以处理阻塞队列里的任务
private static final int RUNNING = -1 << COUNT_BITS;
//不接受新的任务,但是可以处理阻塞队列里的任务
private static final int SHUTDOWN = 0 << COUNT_BITS;
//不接受新的任务,不处理阻塞队列里的任务,中断正在处理的任务
private static final int STOP = 1 << COUNT_BITS;
//过渡状态,也就是说所有的任务都执行完了,当前线程池已经没有有效的线程,
//这个时候线程池的状态将会TIDYING,并且将要调用terminated方法
private static final int TIDYING = 2 << COUNT_BITS;
//终止状态。terminated方法调用完成以后的状态
private static final int TERMINATED = 3 << COUNT_BITS;
1.1 状态转换过程:
-
RUNNING -> SHUTDOWN:手动调用shutdown方法,或者ThreadPoolExecutor要被GC回收的时候调用finalize方法,finalize方法内部也会调用shutdown方法
-
(RUNNING or SHUTDOWN) -> STOP:调用shutdownNow方法
-
SHUTDOWN -> TIDYING:当队列和线程池都为空的时候
-
STOP -> TIDYING:当线程池为空的时候
-
TIDYING -> TERMINATED:terminated方法调用完成之后
1.2 状态和线程数
ThreadPoolExecutor内部还保存着线程池的有效线程个数。状态和线程数在ThreadPoolExecutor内部使用一个整型变量保存,一个变量表示两种含义。整型中32位的前3位用来表示线程池状态,后面表示线程池中有效的线程数。private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// 得到线程数,也就是后29位的数字。 直接跟CAPACITY做一个与操作即可,
//CAPACITY就是的值为 1 << 29 - 1 = 00011111111111111111111111111111。
// 与操作的话前面3位肯定为0,相当于直接取后29位的值
private static int workerCountOf(int c) { return c & CAPACITY; }
// 得到状态,CAPACITY的非操作得到的二进制位11100000000000000000000000000000,然后做在一个与操作,相当于直接取前3位的的值
private static int runStateOf(int c) { return c & ~CAPACITY; }
// 或操作,更新数量和状态两个操作
private static int ctlOf(int rs, int wc) { return rs | wc; }
2. Worker
线程池中肯定有一些执行任务的线程,这些线程被包装为Worker类。同时它还继承了AQS,也实现了Runnable的类:
private final class Workerextends AbstractQueuedSynchronizer implements Runnable {
final Thread thread;
Runnable firstTask;
volatile long completedTasks;
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
public void run() {
runWorker(this);
}
//...
}
它的构造函数只接受一个Runnable参数,内部保存着这个Runnable属性,还有一个thread线程属性用于包装这个Runnable(这个thread属性使用ThreadFactory构造,在构造函数内完成thread线程的构造),另外还有一个completedTasks计数器表示这个Worker完成的任务数。注意构造Thread参数使用的Runnable其实就是Worker本身。
3. 执行任务
使用ThreadPoolExecutor执行任务的时候,可以使用execute或submit方法,submit方法的实现是在AbstractExecutorService中:
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
使用FutureTask包装一个Runnable,这个FutureTask就是返回值。由于submit方法内部调用execute方法,所以execute方法就是执行任务的方法,来看一下execute方法。
public void execute(Runnable command) {
int c = ctl.get();
//满足线程池中的线程数量小于coresize
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
int recheck = ctl.get();
// 线程池的线程数量大于等于coresize,并且线程池还在RUNNING状态,阻塞队列也没满的情况,加到阻塞队列里
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
//再次判断线程池状态
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
// 注意第一个参数为null,因为任务已经添加阻塞队列中,因此不必设置worker的first任务
addWorker(null, false);
//直接使用线程池最大大小。addWorker方法第二个参数false表示使用最大线程数
} else if (!addWorker(command, false))
reject(command);
}
execute方法内部分3个步骤进行处理。
- 如果当前正在执行的Worker数量比corePoolSize(基本大小)要小。直接创建一个新的Worker加入线程池中并执行任务,如果添加成功,直接返回。否则继续往下执行。
- 如果当前线程池是运行状态并且任务添加到阻塞队列成功,再次判断线程池的运行状态,如果不是运行状态,由于之前已经把command添加到workQueue中了,这时需要移除该command 。执行handler使用拒绝策略对该任务进行处理,整个方法返回。如果活跃的线程数为0,新建一个Worker。
- 执行到这里,有两种情况:1. 线程池已经不是RUNNING状态;2. 线程池是RUNNING状态,但workerCount >= corePoolSize并且workQueue已满。 这时再次调用addWorker方法,如果失败则拒绝该任务,失败的原因不外乎线程数大于maxSize。
addWorker方法的主要工作是在线程池中创建一个新的线程并执行,firstTask参数 用于指定新增的线程执行的第一个任务,core参数为表示在新增线程时会判断当前活动线程数是否少于corePoolSize。
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);//获取线程池的状态
//省略状态判断,以及任务队列null检查
for (;;) {
int wc = workerCountOf(c);
// 如果线程池线程数量超过线程池最大容量或者线程数量超过了coresize
if (wc >= CAPACITY ||wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 没有超过各种大小的话,cas操作线程池线程数量+1,cas成功的话跳出循环
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // 重新检查状态
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 {
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
// 得到线程池的可重入锁
final ReentrantLock mainLock = this.mainLock;
mainLock.lock(); // 锁住,防止并发
try {
//再重新获取一下状态
int rs = runStateOf(ctl.get());
//如果线程池在RUNNING状态或者线程池在SHUTDOWN状态并且任务是个null
if (rs < SHUTDOWN ||(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);
workerAdded = true;// 标识任务已经添加成功
}
} finally {
mainLock.unlock();
}
// 如果任务添加成功,运行任务,改变一下任务成功启动标识
if (workerAdded) {
t.start();// 相当于就是调用了Worker的run方法
workerStarted = true;
}
}
} finally {
if (! workerStarted)// 如果任务启动失败,调用addWorkerFailed方法
addWorkerFailed(w);
}
return workerStarted;
}
Worker中的线程start的时候,调用Worker本身run方法,这个run方法之前分析过,调用外部类ThreadPoolExecutor的runWorker方法,直接看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 {
// 如果worker中的任务不为空,继续循环,否则使用getTask获得任务。一直死循环,除非得到的任务为空才退出
while (task != null || (task = getTask()) != null) {
w.lock(); // 如果拿到了任务,给自己上锁,表示当前Worker已经要开始执行任务了,已经不是闲置Worker
// 在执行任务之前先做一些处理。
// 1. 如果线程池已经处于STOP状态,并且线程没有中断状态为false,设置线程中断状态
// 2. 如果线程池还处于RUNNING或SHUTDOWN状态,并且当前线程已经被中断了,Thread.interrupted()方法会复位中断的状态,再次设置线程中断状态。
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();//这里run的时候可能会被中断,比如线程池调用了shutdownNow方法
} finally {
task = null;
w.completedTasks++;// 记录执行任务的个数
w.unlock(); // 执行完任务之后,解锁,Worker变成闲置Worker
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
第一次进入循环时,task为firstTask,不为null,直接进入循环;从而行执行的是firstTask的run()方法,finally代码块中,task会被置为null,导致下一轮循环。
总结一下runWorker方法的执行过程:
- while循环不断地通过getTask()方法获取任务;
- getTask()方法从阻塞队列中取任务;
- 如果线程池正在停止,那么要保证当前线程是中断状态,否则要保证当前线程不是中断状态;
- 调用task.run()执行任务;
- 如果task为null则跳出循环,执行processWorkerExit()方法;
- runWorker方法执行完毕,也代表着Worker中的run方法执行完毕,销毁线程。
下面介入getTast方法。
private Runnable getTask() {
boolean timedOut = false; // 阻塞队列获取任务超时标志
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc= workerCountOf(c);
// timed变量用于判断是否需要进行超时控制。
// allowCoreThreadTimeOut默认是false,也就是核心线程不允许进行超时;
// wc > corePoolSize,表示当前线程池中的线程数量大于核心线程数量;
// 对于超过核心线程数量的这些线程,需要进行超时控制
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1||workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// 根据timed来判断,如果为true,则通过阻塞队列的poll方法进行超时控制,如果在keepAliveTime时间内没有获取到任务,则返回null;否则通过take方法,如果这时队列为空,则take方法会阻塞直到队列不为空。
Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS):workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
workQueue是一个线程安全的BlockingQueue,大部分时候使用的实现类是LinkedBlockingQueue,假设timed为false,则调用阻塞的take()方法,返回的r一定不是null。
当前线程池的线程数量超过了corePoolSize且小于maximumPoolSize,并且workQueue已满时,则可以增加工作线程,但这时如果超时没有获取到任务,也就是timedOut为true的情况,说明workQueue已经为空了,也就说明了当前线程池中不需要那么多线程来执行任务了,可以把多于corePoolSize数量的线程销毁掉,保持线程数量在corePoolSize即可。