本文详细解析了Java中ThreadPoolExecutor的内部实现原理，包括成员变量、构造方法、execute方法及shutdown系列方法的源码分析。重点介绍了线程池的状态转换、任务分配策略以及线程池的启动与关闭流程。
本文概要
- 成员变量
- 构造方法
- 准备知识
- execute方法源码解析
- shutdown方法源码解析
- shutdownNow方法源码解析
首先我们来看下ThreadPoolExecutor类的成员变量
成员变量
public class ThreadPoolExecutor extends AbstractExecutorService {
// ctl的值由线程池状态和线程池数量组成，后面会具体讲
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// 这个数字。主要用作下面的容量、线程池状态的移位计算
private static final int COUNT_BITS = Integer.SIZE - 3;
// 线程最大的数量【值等于：（1 << 29） - 1】
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
/*
* 下面是线程池的状态
* execute(Runnable) ： RUNNING
* shutdown()：RUNNING -> SHUTDOWN -> TIDYING -> TERMINATED
* shutdownNow()：RUNNING -> STOP-> TIDYING -> TERMINATED
*/
// RUNNING 值为【-1 << 29】
private static final int RUNNING = -1 << COUNT_BITS;
// SHUTDOWN 值为【0 << 29】
private static final int SHUTDOWN = 0 << COUNT_BITS;
// STOP 值为【1 << 29】
private static final int STOP = 1 << COUNT_BITS;
// TIDYING 值为【2<< 29】
private static final int TIDYING = 2 << COUNT_BITS;
// TERMINATED 值为【3 << 29】
private static final int TERMINATED = 3 << COUNT_BITS;
// 存储Runnable任务的队列
private final BlockingQueue<Runnable> workQueue;
private final ReentrantLock mainLock = new ReentrantLock();
// 存储Worker的容器
private final HashSet<Worker> workers = new HashSet<Worker>();
private final Condition termination = mainLock.newCondition();
// 最大的线程数
private int largestPoolSize;
// 总共完成的任务数量
private long completedTaskCount;
// 线程工厂，用于创建线程
private volatile ThreadFactory threadFactory;
// 拒绝策略
private volatile RejectedExecutionHandler handler;
// 线程存活时间
private volatile long keepAliveTime;
// 核心线程数
private volatile int corePoolSize;
// 最大线程数
private volatile int maximumPoolSize;
// 默认拒绝策略
private static final RejectedExecutionHandler defaultHandler =
new AbortPolicy();
}
构造方法
它具有4个构造方法
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, defaultHandler);
}
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;
}
它的构造方法非常简单，只是进行一些简单的成员变量赋值。
在看execute()执行Task源码之前，需要看看几个比较关键的方法。
准备知识
由上面的成员量我们知道，线程池它主要由RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED这5个状态。下面我们来看一下
由上面可知每个状态的值为：
由上面的值可知道 ：TERMINATED > TIDYING > STOP > SHUTDOWN > RUNNING，而且线程状态主要由int的前三个字节决定
线程数的最大数量为 private static final int CAPACITY = (1 << COUNT_BITS) - 1;
CAPACITY : 00011111 11111111 11111111 11111111
下面我们几个关键方法
1、ctlOf
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static int ctlOf(int rs, int wc) {
return rs | wc;
}
这个方法是设置当前线程池的状态，很明显，ctl的初始值是 RUNNING | 0 = RUNNING【10100000 00000000 00000000 00000000】
2、workerCountOf
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
private static int workerCountOf(int c) {
return c & CAPACITY;
}
这个方法是计算当前线程池的线程数，上面方法的c一般是ctl.get()的值
举个例子：ctl.get()的值是【10100000 00000000 00000000 10000011】，那么通过workerCountOf计算得出当前的线程数为：
最终的值为ctl.get()值的后29位也就是【00000000 00000000 00000000 10000011】。所以从这里我们可以得出一个结论，线程池的状态和线程池的线程数量由一个int的32字节组成，由下图
3、runStateOf
private static int runStateOf(int c) {
return c & ~CAPACITY;
}
这个方法是获取当前线程池的状态：这个c一般是ctl.get()的值
举个例子，当前ctl.get()的值是【10100000 00000000 00000000 10000011】
最终的值为【10100000 00000000 00000000 00000000】也就是RUNNING的值
4、runStateLessThan
private static boolean runStateLessThan(int c, int s) {
return c < s;
}
判断c状态是否小于s状态。上面我们可以知道TERMINATED > TIDYING > STOP > SHUTDOWN > RUNNING
所以比如调用runStateLessThan(c,SHUTDOWN)，那么这里只有c=RUNNING，才会返回true，其它都返回false
5、runStateAtLeast
private static boolean runStateAtLeast(int c, int s) {
return c >= s;
}
判断c状态是否大于等于s状态，跟上面个方法差不多。
6、isRunning
private static boolean isRunning(int c) {
return c < SHUTDOWN;
}
判断c状态是否为RUNNING状态
execute方法源码解析
有了上面的准备知识我们就可以看execute()方法的源码
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
*
* 2. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
*
* 3. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
*/
// 获取ctl的值
int c = ctl.get();
/*
* workerCountOf(c)：计算当前线程数
*/
if (workerCountOf(c) < corePoolSize) {
// 如果当前线程数 < corePoolSize，那么调用addWorker创建一个新的线程去执行Task
if (addWorker(command, true))
return;
// 如果创建线程失败，那么获取ctl的值，因为可能线程池的状态变了
c = ctl.get();
}
// 判断当前线程池状态是否为RUNNING，并且往队列中放入一个Task
if (isRunning(c) && workQueue.offer(command)) {
// 重新获取当前线程池状态
int recheck = ctl.get();
// 如果当前线程池状态不是RUNNING，那么把Task从队列中移除
if (! isRunning(recheck) && remove(command))
// 执行拒绝策略
reject(command);
// 如果当前线程池状态是RUNNING，并且线程数为0
else if (workerCountOf(recheck) == 0)
// 调用addWork创建一个线程去执行TASK
addWorker(null, false);
}
// 如果当前线程池状态不是RUNNING或者往队列满了，那么调用addWorker创建一个线程执行Task
else if (!addWorker(command, false))
// 如果当前线程池状态不是RUNNING，并且队列已经满了，并且当前线程数 = maximumPoolSize，那么执行拒绝策略
reject(command);
}
由上面可知，我们可以做一个简单的总结，然后在依次分析：
- 判断线程数是否小于corePoolSize，如果小于，那么直接调用addWorker创建线程去执行Task
- 如果线程数大于或者等于corePoolSize，那么首先判断线程池是否为RUNNING，如果队列没满，把Task放到队列中
- 如果队列满了，那么调用addWorker方法，创建一个新的线程去执行Task，直到线程数等于maximumPoolSize为止
- 如果此时队列满了，而且线程数也等于maximumPoolSize，那么调用reject方法，执行拒绝策略
addWorker
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
// 这里一个死循环
for (;;) {
// 获取ctl的值，前面说过这个值包含当前线程池的状态和线程池的数量
int c = ctl.get();
// 获取当前线程池的状态
int rs = runStateOf(c);
// Check if queue empty only if necessary.
/*
* rs >= SHUTDOWN
* rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty()
* 这里什么时候才会返回false，三种情况
* 1、当前线程状态为STOP，也就是调用了shutdownNow()
* 2、当前线程状态为SHUTDOWN，并且firstTask == null，但是队列为空
* 3、当前线程为SHUTDOWN，并且firstTask != null。也就是用户调用了shutdown()，然后又调用
* exeute(Runnable)，那么这种情况下，很明显这里也会返回false
*/
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
// 这里又一个死循环
for (;;) {
// 获取当前线程池的线程数
int wc = workerCountOf(c);
/*
* 如果线程数wc >= CAPACITY ，那么直接返回false
* 如果这里 core=true, 还需要判断wc >= corePoolSize
* core = false，那么需要判断wc >= maximumPoolSize
*/
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
/*
* 如果前面判断通过后，那么调用CAS让ctl的值+1
*/
if (compareAndIncrementWorkerCount(c))
/*
* 如果CAS成功，那么直接跳出最外层retry循环
*/
break retry;
/*
* 如果CAS失败，那么重新获取ctl的值
*/
c = ctl.get(); // Re-read ctl
/*
* 判断当前的状态是否被改变了，
* 1、如果状态被改变了，那么进行跳出内层循环，进行retry循环
* 2、如果当前状态没有被改变，那么进行内层循环
*/
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
/*
* 进入到这里，说明ctl已经成功调用CAS并且值+1
*/
/*
* 定义2个标识
* workerStarted ：Worker是否成功start
* workerAdded : Worker是否成功被添加到容器中
*/
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
/*
* 创建了一个Worker，Worker里面封装了Thread，下面我们可以看下Worker的构造方法
* Worker(Runnable firstTask) {
* setState(-1); // inhibit interrupts until runWorker
* this.firstTask = firstTask;
* this.thread = getThreadFactory().newThread(this);
* }
*/
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
// 对线程池加锁
mainLock.lock();
try {
// 重新获取线程池状态，因为可能刚刚创建Worker的时候，线程池状态就被改变了
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
/*
* 进入这里，说明线程池状态为RUNNING
*/
// 往容器中添加新建的Worker
workers.add(w);
// 获取当前容器中的数量
int s = workers.size();
// 如果当前数量 > 最大Worker数量
if (s > largestPoolSize)
// 把s 赋值给largestPoolSize
largestPoolSize = s;
// 把workerAdded标识为true
workerAdded = true;
}
} finally {
// 解锁
mainLock.unlock();
}
if (workerAdded) {
// 开启Worker里的Thread线程
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
/*
* 如果开启线程失败，那么调用addWorkerFailed方法，把刚新建的Worker从容器中去除，
* 并且把ctl - 1
*/
addWorkerFailed(w);
}
return workerStarted;
}
看到这里，可能就有几个疑问
- Worker是如何执行Task
- 如果Worker的数量大于maximumPoolSize的时候，那么是怎么回收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. */
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) {
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.
protected boolean isHeldExclusively() {
return getState() != 0;
}
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(); }
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
从上面我们可以知道当调用start()的时候，会执行Worker的run()，run实际上执行的是runWorker
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
/*
* 这个标识主要是标识Worker是正常回收还是异常退出
* true : 执行task出现异常，异常退出
* false ： 正常回收
*/
boolean completedAbruptly = true;
try {
// 死循环，调用getTask()，不断从队列中获取Task，如果返回Task为null，那么就需要回收Worker
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
/*
* 这里主要判断 判断当前线程池状态是否>= STOP
*/
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
// 调用Thread.interrupt()
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
// 取出的Task，直接调用run方法进行运行
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;
// 成功运行的Task数量+1
w.completedTasks++;
w.unlock();
}
}
// 标记completedAbruptly为false，标记是正常回收Worker
completedAbruptly = false;
} finally {
// 执行Worker退出的一些操作
processWorkerExit(w, completedAbruptly);
}
}
紧接着我们看下getTask()和processWorkerExit()
getTask()
这个方法主要是从队列中获取Task，如果这里返回null，那么意味着需要回收Worker
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
// 获取ctl的值
int c = ctl.get();
// 获取当前线程池的状态
int rs = runStateOf(c);
// Check if queue empty only if necessary.
/*
* 判断当前线程池的状态 >= SHUTDOWN 而且 （队列为空 或者 线程池状态 >= STOP）
*/
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
/*
* 这里有两种情况会进来
* 1、调用shutdown()，并且队列为空
* 2、调用shutdownNow()【这种情况不管队列是否空】
*/
// ctl执行CAS -1
decrementWorkerCount();
// 返回null
return null;
}
// 获取线程池的线程数量
int wc = workerCountOf(c);
// Are workers subject to culling?
// 默认allowCoreThreadTimeOut为false，所以这里wc > corePoolSize的话，timed=true
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
/*
* 这里有3种情况会进来
* 1、allowCoreThreadTimeOut = true 并且 Worker从队列中获取任务超时，并且线程数 > 1
* 2、allowCoreThreadTimeOut = true 并且 Worker从队列中获取任务超时，并且线程数 = 1
* 而且队列为空
* 3、allowCoreThreadTimeOut = false 但是 线程数 > corePoolSize，而且 队列为空
*/
// 让ctl的值-1，返回null
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
/*
* timed = true，调用poll()等待keepAliveTime s从队列中取任务，然后程序往下走
* timed = false，调用take()，直到队列中有任务，程序才往下走
*/
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
// 获取的任务Task不为空，那么直接返回Task
if (r != null)
return r;
// 获取的任务超时，标记超时timeOut=true
timedOut = true;
} catch (InterruptedException retry) {
/*
* 这种情况是：线程在从队列中阻塞等待任务时，被调用了Thread.interrupt()，那么就会跳到这里
* 标记timeOut=false
*/
timedOut = false;
}
}
}
processWorkerExit()
这个方法主要是Worker执行退出后的一些操作
/*
* 上面说过 completedAbruptly的含义
* true : 执行task出现异常，异常退出
* false: 正常回收
*
*/
private void processWorkerExit(Worker w, boolean completedAbruptly) {
// 判断Worker是否正常退出
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
// 如果是异常退出，那么需要将ctl的值-1
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 计算完成的任务总数
completedTaskCount += w.completedTasks;
// 把Worker从容器中移除
workers.remove(w);
} finally {
mainLock.unlock();
}
// 尝试去终止线程池，也就是把线程池状态变为TERMINATED
tryTerminate();
// 获取ctl的值
int c = ctl.get();
// 判断当前线程池的状态是否小于STOP【也就是RUNNING或者SHUTDOWN】
if (runStateLessThan(c, STOP)) {
// 判断当前线程是否正常退出
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
// 判断当前线程池的线程数是否大于等于min
if (workerCountOf(c) >= min)
// 如果是 那么Worker直接退出
return; // replacement not needed
}
/*
* 会有两种情况执行到这里,前提当前线程池的状态是RUNNING或者是SHUTDOWN：
* 1、异常退出，也就是completedAbruptly为true
* 2、正常退出，也就是completedAbruptly为false，但是线程数小于min
*/
addWorker(null, false);
}
}
tryTerminate
每次回收Worker或者异常退出一个Worker，他都会是尝试去中断线程池
final void tryTerminate() {
for (;;) {
// 获取ctl的值
int c = ctl.get();
/*
* 这里有三种情况 直接return
* 1、线程池状态还是RUNNING
* 2、线程池状态大于等于TIDYING【也就是TIDYING或者TERMINATED】
* 3、线程池状态是SHUTDOWN 而且队列不为空
*/
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
/*
* 判断线程数是否不等于0
*/
if (workerCountOf(c) != 0) { // Eligible to terminate
/*
* 回收阻塞的线程，这里实际上就是遍历Workers，然后调用每个Worker的Thread.interrupt()
*/
interruptIdleWorkers(ONLY_ONE);
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 把线程池状态改为TIDYING
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
// 执行terminated钩子方法
terminated();
} finally {
// 执行terminated方法后，把线程池状态改为TERMINATED
ctl.set(ctlOf(TERMINATED, 0));
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
shutdown()
这个方法是停止线程池，调用完这个方法后，进行往线程池里面提交任务，将不会被执行。但是如果队列里还有任务，那么会继续执行队列的任务。
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
// 把线程池状态改变为SHUTDOWN
advanceRunState(SHUTDOWN);
// 去中断一些没事干在等待的Worker
interruptIdleWorkers();
// 执行onShutdown钩子函数
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
// 尝试去中断线程池
tryTerminate();
}
private void advanceRunState(int targetState) {
for (;;) {
int c = ctl.get();
if (runStateAtLeast(c, targetState) ||
ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
break;
}
}
private void interruptWorkers() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers)
w.interruptIfStarted();
} finally {
mainLock.unlock();
}
}
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
shutdownNow()
这个方法跟shutdown()方法有点区别，它不管你队列里是否还有任务，它会里面停止，所以这个方法慎用，会造成Task丢失。
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
// 把线程池状态改变为STOP
advanceRunState(STOP);
// 去中断一些没事干在等待的Worker
interruptWorkers();
// 获取队列中没有执行完的Task
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
扫一扫
461
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
