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即可。
945
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
