1.线程池的初始化
- 构造参数
| 参数名称 | 说明 |
|---|---|
| int corePoolSize | 核心线程数 |
| int maximumPoolSize | 最大线程数 |
| long keepAliveTime | 空闲线程存活时间数量 |
| TimeUnit unit | 空闲线程存活时间单位 |
| BlockingQueue |
任务队列 |
| ThreadFactory threadFactory | 线程工厂,可以自定义创建线程 |
| RejectedExecutionHandler handler | 拒绝策略 |
- 提交任务方法 execute解析
public void execute(Runnable command)
第一步，首先创建核心线程处理任务
//判定线程池线程数量是否小于核心线程数
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
//增加核心线程数成功直接返回
if (addWorker(command, true))
return;
c = ctl.get();
}
第二步，走到这一步，说明核心线程已经创建完毕，新提交的任务走下面的处理流程
//检查线程池状态，并且将任务加入队列
if (isRunning(c) && workQueue.offer(command)) {
//double check线程池状态
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
//线程池状态不符合条件，则从队列移除任务并且使用拒绝策略处理任务
reject(command);
//线程池状态符合条件，但发现线程数为0，则增加线程，觉得是个兜底，
//防止出现任务队列有任务却没有线程来处理的情况，极端情况下会有所有线程都销毁了
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
第三步，任务队列满了，会尝试建立非核心线程处理任务，否则使用拒绝策略
else if (!addWorker(command, false))
//如果创建非核心线程失败（达到最大线程数），则任务交给拒绝策略来处理
reject(command);
小结,提交任务处理流程
| 序号 | 条件 | 动作 |
|---|---|---|
| 1 | 线程数| 新建核心线程，处理任务 |
|
| 2 | 线程数>= corePoolSize 并且 workQueue 不满 | 将任务加入workQueue |
| 3 | corePoolSize <= 线程数 < maximumPoolSize 并且workQueue 满了 | 创建非核心线程处理任务 |
| 4 | 线程数> maximumPoolSize 并且workQueue 满了 | 使用拒绝策略处理任务 |
2.核心方法addWorker解析
private boolean addWorker(Runnable firstTask, boolean core)
| 参数名称 | 说明 |
|---|---|
| Runnable firstTask | 处理的任务，可以为空，创建线程时不处理任务 |
| boolean core | 是否为核心线程 |
第一部分，判断线程池是否符合增加线程r条件，不可以直接返回false
符合条件，直接cas增加线程池线程数量继续，并继续下一步真正的增加线程
不符合条件的情况
1.线程池状态为STOP、TIDYING、TERMINATED,这些状态下不允许增加Worker
2.线程池状态为SHUTDOWN
2.1新提交的任务不为空 或者 2.2新提交的任务为空，并且队列为空
相当于判断条if (rs == SHUTDOWN && (firstTask != null || workQueue.isEmpty())) return false;
2.1的情况，SHUTDOWN状态下线程池不接受新任务，所以返回false
2.2的情况，SHUTDOWN状态下,新任务为空，这种情况为单纯的增加线程，例如execute中这段代码
else if (workerCountOf(recheck) == 0)
addWorker(null, false)
此时,SHUTDOWN状态下且任务队列为空，即不存在需要执行的任务，无需增加线程，所以也返回false
3.线程数量超限
3.1 超过线程池最大线程容量(一般不会，很大的一个数)
3.2 超过核心线程数，或者最大线程数
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount(c))
//cas 数量增加成功，则跳出循环进行到下一步
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
第二部分，真正的去增加线程
创建Worker，加入到线程池，并启动Worker
将worker加入到线程池前，会再次检查线程池的状态，
因为并发情况下execute、shutdown、shutdownNow等方法完全可能并发执行，mainLock保护之外的代码都可能并行
worker成功加入线程池后，会启动该worker
启动失败执行 addWorkerFailed 移除worker，维护数量，并且尝试中止线程池，这种情况往往是线程池状态发生变化
操纵线程池的wokers列表，都是在mainlock的保护之下进行的，所以不会存在并发问题
boolean workerStarted = false;
boolean workerAdded = false;
ThreadPoolExecutor.Worker w = null;
try {
w = new ThreadPoolExecutor.Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
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());
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;
3.Worker的运行
3.1 构造worker
Worker(Runnable firstTask) {
//线程中断之前都会判定state>=0，这里设置state为-1 保证运行runwoker前不被中断，
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
//把自身当做runnable传入线程,线程start会调用woker的run方法
this.thread = getThreadFactory().newThread(this);
}
public void run() {
runWorker(this);
}
3.2 runWorker方法
final void runWorker(ThreadPoolExecutor.Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
//unlock将state设置为0，之后就允许打断当前线程了
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
//循环获取任务，当获取任务为空或者执行任务抛异常，线程结束，注意这两个就是线程结束的条件
// getTask方法可能阻塞等待,阻塞的过程其实就是线程空闲的过程，阻塞超过时限，就会获取不到任务，进而线程会结束
while (task != null || (task = getTask()) != null) {
//在worker锁的保护之下执行任务，获取这个lock以后，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
//如果线程池正在终止，确保当前线程处于打断状态，task仍然会被执行，但下次循环getTask会为空，进而worker退出
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();
}
}
//正常结束，会有这个标识，如果异常结束则为true
completedAbruptly = false;
} finally {
//线程结束后执行
processWorkerExit(w, completedAbruptly);
}
}
3.3 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.线程池状态大于等于STOP 返回null，worker退出
* 线程池状态=SHUTDOWN 并且任务队列为空,返回null，worker退出
*/
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
/**
* 判断当前线程是否允许超时
* 1.设置核心线程允许超时allowCoreThreadTimeOut
* 2.线程池当前线程数超过核心线程数
*/
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
/**
* 判断当前线程是否可以退出
* 第一步 判定当前线程是否符合退出的基本条件
* 1.线程池线程数大于最大线程数 （为了保证线程池数量可控）或者
* 2.当前线程允许超时并且已经超时（为了处理真正超时的线程）
* 符合线程退出的基本条件以后再进行第二步的判断
* 第二步，判定当前的线程池状态，是否可以支持线程退出
* 1,线程池线程数 大于1 （不是最后一个线程就可以直接退出）或者
* 2.线程池任务队列为空（相当于(wc <= 1 && workQueue.isEmpty()) 最后一个线程需要队列为空才可以退出）
* 符合两步的条件的线程，可以正常退出
*/
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
//cas失败，继续自旋
continue;
}
//获取任务
try {
//worker线程会在这里阻塞等待获取任务，如果woker线程允许超时，则阻塞等待一段时间
//不允许超时，则会一直阻塞在这里，直到能获取到任务
//这里会响应中断，一旦线程池关闭，会中断worker线程，等待任务的阻塞状态将被打破
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
//获取不到任务，则标记为超时，继续下次循环从而返回任务为空
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
3.4 processWorkerExit方法
//异常退出，需要维护线程数量
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();
}
//worker数量减少，尝试中止线程池
tryTerminate();
int c = ctl.get();
//线程池没有中止的话
if (runStateLessThan(c, STOP)) {
//正常退出的情况
if (!completedAbruptly) {
//计算线程池最小维持线程数
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
//线程池数量多于最小维持数量，则直接结束,这里就是worker的run方法真正结束的地方了
if (workerCountOf(c) >= min)
return; // replacement not needed
}
//非正常退出的情况，再次增加worker，比如worker执行任务时抛异常了导致worker结束，需要追加新的worker
addWorker(null, false);
}
4.线程池的关闭
4.1 shutdown方法
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
//修改线程池状态，这步以后线程池不再接收新的任务了，加入不到任务队列
advanceRunState(SHUTDOWN);
//中断非执行状态的worker，从这里可以看出shutdown不会中断运行中（正在执行任务）的worker
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
//尝试中止线程池
tryTerminate();
4.2 shutdownNow
关闭比较暴力，可能会丢失任务
List tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
//修改线程池状态，这步以后线程池不再接收新的任务了，加入不到任务队列
advanceRunState(STOP);
//打断所有的worker
interruptWorkers();
//返回任务队列中没有执行的任务
tasks = drainQueue();
} finally {
mainLock.unlock();
}
//尝试中止线程池
tryTerminate();
return tasks;
4.3 interruptIdleWorkers
中断未执行任务的worker
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (ThreadPoolExecutor.Worker w : workers) {
Thread t = w.thread;
if (!t.isInterrupted() && w.tryLock()) {
//这里能获取worker的锁，说明worker处于非执行任务状态，执行任务状态下获取不到锁
try {
t.interrupt();
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
if (onlyOne)
break;
}
} finally {
mainLock.unlock();
}
4.4 interruptWorkers
中断所有的worker
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (ThreadPoolExecutor.Worker w : workers)
//这里不管woker是否在执行任务，直接打断
w.interruptIfStarted();
} finally {
mainLock.unlock();
}
4.5 tryTerminate
尝试中止线程池，此方法被可能中止线程池的操作调用，如下
1.减少线程数量
2.在shutdown过程中移除任务
3.加入worker失败
4.shutdownNow 过程
5.worker执行完毕
for (;;) {
int c = ctl.get();
/**
* 这几种情况，不需要进一步终止，直接返回
* 1,线程池状态：RUNNING,TIDYING,TERMINATED
* 2. SHUTDOWN状态下，且队列不为空
*/
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
//执行到这里说明，线程池处于SHUTDOWN 并且workQueue空了 or STOP （这个状态不用关心workQueue）
if (workerCountOf(c) != 0) { // Eligible to terminate
//线程池线程数量不为0，中断一个空闲的Worker
interruptIdleWorkers(ONLY_ONE);
return;
}
//执行到这里，说明线程池线程数量为0了，可以关闭线程池了
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//在mainlock的保护之下，更改线程池状态到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
}
5.涉及到的锁
mainLock 线程池级别的锁
更改线程池状态，以及访问workers列表（循环，增加、移除），都需要mainlock的保护下进行
worker lock ,worker级别的锁
worker获取任务以后，需要获取该锁，然后执行任务，任务执行完毕释放该锁
判定worker是否可以被中断，也是通过该锁，其他线程如果能获取该锁，说明worker处于没有正在执行任务的状态，可以进行中断操作