ThreadPoolExecutor是Java线程的实现之一。
使用线程池的好处:
降低系统资源消耗,避免创建与销毁线程带来的资源消耗。
提高响应速度,任务可以从已经从线程池里获取一条线程执行而不必new 一条线程执行。
方便线程的管理与监控。
线程状态
状态说明:
RUNNING 接受新任务和已入队的任务
SHUTDOWN 不接受新任务但处理已入队的任务
STOP 不接受新任务,不处理已入队的任务,会终止正在进行的任务。
TIDYING 所有任务都已经终止了,woker的数量已经为0, 线程会转换成tidying状态,并调用terminated()方法
TERMINATED terminated()方法已经执行完毕。
状态转换
RUNNING -> SHUTDOWN 执行了shutdown()
(RUNNING or SHUTDOWN) -> STOP 执行了shutdownNow()
SHUTDOWN -> TIDYING 工作队列为空并且线程池工作线程数量为0
STOP -> TIDYING 线程池工作线程数量为0
TIDYING -> TERMINATED terminated() 方法执行完毕。
构造函数
corePoolSize:核心线程数量,除非设置allowCoreThreadTimeOut,否则线程池会一直持有corePoolSize数量的线程。
maximumPoolSize:最大线程数量,线程池能够允许的最大线程池数量。
keepAliveTime:保持存活的时间,当线程池的线程数量大于corePoolSize,处于空闲状态的线程超过这个时间没有任务可以执行就会结束。
unit:keepAliveTime时间单位。
workQueue:任务队列。
threadFactory:线程工厂。
RejectedExecutionHandler handler:拒绝策略处理类。可能是线程池关闭了或者饱和了。
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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
execute操作
1线程数少于corePoolSize时,创建新的线程执行任务。
2线程数大于corePoolSize,任务队列未满时,任务加入队列等待线程执行。
3线程数大于corePoolSize 小于maximumPoolSize,任务队列满时,创建新的线程执行任务。
4当3不满足时执行拒绝策略操作。
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
addWorker
该方法主要的工作是创建一个携带任务的Woker到wokers集合,Woker会绑定一条线程,同时这条线程会调用start()方法。由此看出woker就是一条线程。
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
//检测运行状态是SHUTDOWN,STOP,TIDYING,TERMINATED 并且只要下面的任何一个条件成立即可返回false
//1:状态不是SHUTDOWN,例如STOP,TIDYING,TERMINATED那么不能再添加woker了
//2:状态是SHUTDOWN,不再接受任务了,firstTask不为空,也不行
//3:状态SHUTDOWN,firstTask为空,工作队列也为空,不能再添加woker
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
//状态发生改变,就重试
for (;;) {
int wc = workerCountOf(c);
//线程大于CAPACITY 或者
//添加的是core线程的话,工作线程大于corePoolSize否则maximumPoolSize 的话 也返回false
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//增加wc的数量
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
//状态发生改变重新循环
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 {
//创建Woker 并且绑定了一条线程
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
//只让一个线程进来,涉及到共享变量wokers 和 largestPoolSize变量的修改
mainLock.lock();
try {
int rs = runStateOf(ctl.get());
//如果是运行状态 或者
//是SHUTDOWN状态 && 传入任务为空
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();
}
//添加成功 调用Thread.start()方法
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
Worker
继承里 AbstractQueuedSynchronizer 采用独占模式来加锁。
lock成功说明worker在执行任务,unlock说明没有执行任务可以被中断。
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
Worker(Runnable firstTask) {
setState(-1); // 设置AQS state = -1
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
//默认被独占
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(); }
run()方法
worker的run方法调用的是外部类ThreadPoolExecutor的runWorker();
public void run() {
runWorker(this);
}
runWoker()
获取到传入woker的任务 和 从阻塞队列里面获取任务执行,任务存在就执行task.run();
如果task为null,退出循环,调用processWorkerExit线程退出工作,最后run执行完毕,线程销毁。
shutdown方法是怎么优雅的推出的,首先getTask的时候只要是任务队列不为空,就可以继续获取任务,任务不为空循环体内有个检测会清除状态Thread.interrupted(),也即是说只要有任务shutdown还是会接着执行。
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
//unlock说明现在还没有执行任务,就可以被interrupt,也说明阻塞获取任务的时候是可以被中断的
w.unlock();
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
//这里加锁啥表示wokerThread 独占的执行任务,获取了锁那么就不应该被interrupt
w.lock();
// 如果状态至少是STOP状态 进一步确认线程是否interrupted
// 如果没有再一次确认状态是否是STOP状态 && wt没有被中断
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
//中断wokerThrad
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++;
//wokerThread释放锁
w.unlock();
}
}
completedAbruptly = false;
} finally {
//处理woker退出
processWorkerExit(w, completedAbruptly);
}
}
getTask()
从阻塞队列里面获取任务,也有可能因为几种原因推出返回null,
原因1 调用setMaximumPoolSize 可能导致超过最大线程数量。
原因2 线程池已经是STOP,TIYDING,TENIMATED状态了。
原因3 线程池是SHUTDOWN状态,队列为空了。
当设置了keepAliveTime的时候,阻塞队列超过这个时间获取不到任务就会返回null,然后执行processWorkerExit,线程执行完毕,销毁线程。
private Runnable 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.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// 判断是否需要使用keepAliveTime时间
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
shutdown()
设置线程池的状态为SHUTDOWN,中断空闲的worker线程。这个时候不回接受新任务,已经入队的会继续处理。
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(SHUTDOWN);
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
tryTerminate();
}
遍历所有worker线程,如果线程没有被中断并且能获取到独占锁,说明还没有获取任务执行,这个时候就可以中断了。
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers) {
Thread t = w.thread;
if (!t.isInterrupted() && w.tryLock()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
if (onlyOne)
break;
}
} finally {
mainLock.unlock();
}
}
shutdownNow();
这个方法主要是做了3个事情
1设置线程池为STOP状态
2中断所有worker线程
3把任务队列里等待执行的任务移除并返回到一个List里面。
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 遍历所有woker ,不管有没有执行任务 都执行中断。
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) {
}
}
}
拒绝策略(也叫饱和策略)
CallerRunsPolicy 如果线程池没有shutdown,就会由调用线程池执行任务的线程 执行拒绝的任务。
AbortPolicy 抛出异常处理。
DiscardPolicy 直接忽略拒绝任务,啥也不处理
DiscardOldestPolicy 如果线程池没有shutdown,那么会移除工作队列里面最老的任务,然后再用线程池执行当前任务。
总结
线程池的代码设计非常精妙,处理的细节非常多。
简单的描述下excute 任务的流畅,
首先判断是否需要new worker来执行当前任务,还是入队,或者直接拒绝。
当woker运行完第一个任务后,会不断的getTask() 从阻塞队列里面获取任务执行。如果获取任务为空,那么有可能是超时的非核心线程,那么该线程执行完毕结束生命周期。