ThreadPoolExecutor源码解析
一、新建线程池的是构造方法
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
各参数解析
corePoolSize – 核心线程数 要保留在池中的线程数,即使它们处于空闲状态,除非设置了 allowCoreThreadTimeOut
当核心线程数被设置为true后,调用interruptIdleWorkers中断空闲线程的方法、
public void allowCoreThreadTimeOut(boolean value) {
if (value && keepAliveTime <= 0)
throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
if (value != allowCoreThreadTimeOut) {
allowCoreThreadTimeOut = value;
if (value)
interruptIdleWorkers();
}
}
1、 获取当前锁对象并锁住该方法
2、遍历循环工作线程 判断每个线程如果没有中断,并获取当前线程尝试获取锁成功,代表该线程是空闲线程 那么中断这个线程。
3、当只有一个线程的时候,不做处理 线程池中始终会保持一个线程
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();
}
}
maximumPoolSize – 最大线程数 池中允许的最大线程数
keepAliveTime – 当线程数大于核心数时,这是多余空闲线程在终止前等待新任务的最长时间。如果线程池中的线程数量大于 corePoolSize时,如果某线程空闲时间超过keepAliveTime,线程将被终止,直至线程池中的线程数目不大于corePoolSize;如果允许为核心池中的线程设置存活时间,那么核心池中的线程空闲时间超过keepAliveTime,线程也会被终止。
unit – keepAliveTime 参数的时间单位
workQueue – 底层使用BlockingQueue阻塞队列 用于在执行任务之前保存任务的队列。这个队列将只保存 execute 方法提交的 Runnable 任务。
ThreadFactory:创建线程工厂,可以自定义线程工厂给线程池里的线程设置一个自定义线程名。
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "pool-" +
poolNumber.getAndIncrement() +
"-thread-";
}
handler:饱和策略,假如线程池已满,并且没有空闲的线程,这个时候不再允许提交任务到线程池,线程池提供了4中策略,至于具体采用哪种策略还是自定义策略,具体情况具体分析。
AbortPolicy:拒绝提交,直接抛出异常,也是默认的饱和策略;
CallerRunsPolicy:线程池还未关闭时,用调用者的线程执行任务;
DiscardPolicy:丢掉提交任务;
DiscardOldestPolicy:线程池还未关闭时,丢掉阻塞队列最久为处理的任务,并且执行当前任务。
如果以下条件之一成立:corePoolSize < 0 keepAliveTime < 0 maximumPoolSize <= 0 maximumPoolSize < corePoolSize
抛出:
IllegalArgumentException
二、看execute方法
如果当前线程池中的线程数目小于corePoolSize,则每来一个任务,就会创建一个线程去执行这个任务;
如果当前线程池中的线程数目>=corePoolSize,则每来一个任务,会尝试将其添加到任务缓存队列当中,若添加成功,则该任务会等待空闲线程将其取出去执行;若添加失败(一般来说是任务缓存队列已满),则会尝试创建新的线程去执行这个任务;
如果队列已经满了,则在总线程数不大于maximumPoolSize的前提下,则创建新的线程
如果当前线程池中的线程数目达到maximumPoolSize,则会采取任务拒绝策略进行处理;
如果线程池中的线程数量大于 corePoolSize时,如果某线程空闲时间超过keepAliveTime,线程将被终止,直至线程池中的线程数目不大于corePoolSize;如果允许为核心池中的线程设置存活时间,那么核心池中的线程空闲时间超过keepAliveTime,线程也会被终止。
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
1.主池控制状态ctl是一个原子整数,
封装了两个概念字段workerCount,表示有效线程数runState,
表示是否正在运行、正在关闭等为了打包成一个int,
我们限制workerCount为(2^29 )-1(约 5 亿)个线程 --即最多可工作的线程最多为5亿多个
而不是 (2^31)-1(20 亿)个其他可表示的线程。
2、
线程池用ctl的低29位表示线程池中的线程数,高3位表示当前线程状态,后续假如想要增大这个值,可以将AtomicInteger改成AtomicLong。
runState 提供主要的生命周期控制,取值: 111
RUNNING:接受新任务并处理排队任务 000
SHUTDOWN:不接受新任务,但处理排队任务 001
STOP:不接受新任务,不处理排队任务,并中断正在进行的任务 010
TIDYING:所有任务都已终止 011
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();
重新检测线程池是否还在运行 如果没有运行 remove任务 并拒绝任务
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
如果 添加缓存队列失败 那么新建线程数,
如果线程数量大于最大线程数量,那么将使用拒绝策略
else if (!addWorker(command, false))
reject(command);
}
检查是否可以根据当前池状态和给定界限(核心或最大值)添加新的工作线程。
如果是这样,则相应地调整工作人员数量,并且如果可能,将创建并启动一个新工作人员,
将 firstTask 作为其第一个任务运行。如果池已停止或有资格关闭,
则此方法返回 false。如果线程工厂在询问时未能创建线程,它也会返回 false。
如果线程创建失败,无论是由于线程工厂返回 null,还是由于异常
(通常是 Thread.start() 中的 OutOfMemoryError),我们都会干净利落地回滚。
参数:
firstTask – 新线程应该首先运行的任务(如果没有,则为 null)。
当线程少于 corePoolSize 时(在这种情况下我们总是启动一个),
或者当队列已满(在这种情况下我们必须绕过队列)时,
使用初始的第一个任务(在方法 execute() 中)
创建工作线程以绕过队列.最初空闲线程通常通过 prestartCoreThread 创建或替换其他垂死的工人。
core – 如果为 true,则使用 corePoolSize 作为绑定,
否则为 maximumPoolSize。 (此处使用布尔指标而不是值以确保在检查其他池状态后读取新值)。
返回:
如果成功则为真
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
//获取正在运行状态的线程数
int rs = runStateOf(c);
检查 SHUTDOWN =0
rs是否大于0 或者 运行线程是否为空 工作队列是否为空
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
查看线程池中线程的数量
int wc = workerCountOf(c);
线程池中的数量是否大于容量或者wc是否大于核心线程数 返回失败
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
利用cas去添加线程池中的数量 如果成功结束流程 跳出循环
如果失败重新获取C值
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 {
w = new 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;
}