本文为ThreadPoolExecutor源码注释的一个备份。
ThreadPoolExecutor.java。 版本JDK14.0.1
源码解析可以看下面链接中这两篇博客,已经讲得比较清楚了
博客1
博客2
关于其他的细节,见本文中的中文注释
import java.security.Security;
import java.util.concurrent.*;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.atomic.LongAdder;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ThreadPoolExecutor extends AbstractExecutorService {
//保存状态和worker计数,保存为一个变量,方便使用CAS实现条件互斥
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//高3位保存状态,低位保存计数
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int COUNT_MASK = (1 << COUNT_BITS) - 1;
// 线程池的五种状态
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
//取出c中保存的状态
private static int runStateOf(int c) { return c & ~COUNT_MASK; }
//取出c中保存的worker计数
private static int workerCountOf(int c) { return c & COUNT_MASK; }
//将线程池状态rs和worker计数合并到一起
private static int ctlOf(int rs, int wc) { return rs | wc; }
//判断线程池是否处于s状态之前(状态排序RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED)
private static boolean runStateLessThan(int c, int s) {
return c < s;
}
//判断线程池是否处于s之后的状态,包括s
private static boolean runStateAtLeast(int c, int s) {
return c >= s;
}
//判断是否处于running状态
private static boolean isRunning(int c) {
return c < SHUTDOWN;
}
//通过CAS将workercount + 1,返回成功与否
private boolean compareAndIncrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect + 1);
}
//通过CAS将workercount - 1,返回成功与否
private boolean compareAndDecrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect - 1);
}
//直接将workercount - 1,不通过CAS,
void decrementWorkerCount() {
ctl.addAndGet(-1);
}
//任务阻塞队列,保存待执行的任务,通过构造函数传进来。runWorker会从这里面取任务去执行
private final BlockingQueue<Runnable> workQueue;
//一个可重入锁,用于保证workers操作的线程安全,以及相关记账(如largestPoolSize,completedTaskCount)。
// (这将interruptIdleWorkers序列化,避免中断风暴)
private final ReentrantLock mainLock = new ReentrantLock();
//存储所有的worker
private final HashSet<java.util.concurrent.ThreadPoolExecutor.Worker> workers = new HashSet<>();
//等待终止的条件变量,用于调用awaitTermination时的阻塞等待
private final Condition termination = mainLock.newCondition();
//获取到目前为止poolSize的最大值。到目前为止所有时刻worker的最大数量。记账而已,这里面没有什么用
private int largestPoolSize;
//完成执行的任务数,同样只是记账。
private long completedTaskCount;
//线程工厂,worker中的线程通过线程工厂的newThread(Runnable)方法创建线程。默认使用Executors.DefaultThreadFactory线程工厂。
//Executors中还有另一个PrivilegedThreadFactory工厂,通过这个工厂创建线程拥有和创建子线程的父线程有相同的AccessControlContext和ContextClassLoader。
private volatile ThreadFactory threadFactory;
//任务被拒绝时调用的拒绝异常处理器
private volatile RejectedExecutionHandler handler;
//空闲线程的存活时间
private volatile long keepAliveTime;
//如果这个值为ture,则核心线程也会受到keepAliveTime的影响,空闲时间超过这个值就终止线程
//如果这个值为false,则核心线程不受影响,一直存活
private volatile boolean allowCoreThreadTimeOut;
//核心线程数
private volatile int corePoolSize;
//最大线程数量
private volatile int maximumPoolSize;
//当没有设置上面的拒绝异常处理器时,使用的默认异常处理器,即直接抛出RejectedExecutionException
private static final RejectedExecutionHandler defaultHandler =
new java.util.concurrent.ThreadPoolExecutor.AbortPolicy();
//调用shutdown和shutdownNow需要interrupt线程。所以需要验证是否存在修改线程的权限。当不满足权限时,忽略security抛出的异常,不做interrupt
private static final RuntimePermission shutdownPerm =
new RuntimePermission("modifyThread");
//worker类,继承了AbstractQueuedSynchronizer,只是为了复用其中的独占锁。
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
//这个类永远不会被序列化,假如serialVersionUID只是为了避免编译时的警告
private static final long serialVersionUID = 6138294804551838833L;
//和worker绑定的线程
final Thread thread;
//初始化任务,可能是null
Runnable firstTask;
//当前worker完成的任务数计数
volatile long completedTasks;
//将AbstractQueuedSynchronizer替换成AbstractQueuedLongSynchronizer,然后可以将completedTasks放到状态中
// TODO: switch to AbstractQueuedLongSynchronizer and move
// completedTasks into the lock word.
//构造函数
Worker(Runnable firstTask) {
//状态初始化-1,禁止interrupt,runWorker会将state设成0,就允许中断了
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
//实际调用runWorker执行任务
public void run() {
runWorker(this);
}
//state == 0, unlocked
//state == 1, locked
// 被isLocked调用
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;
}
//通过AQS的acquire方法获得锁
public void lock() { acquire(1); }
public boolean tryLock() { return tryAcquire(1); }
//通过AQS的release释放锁
public void unlock() { release(1); }
public boolean isLocked() { return isHeldExclusively(); }
//判断当前状态是否为started,是的话保证当前的interrupted设置为true。如果抛出安全异常,就忽略,相当于什么都不做
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
// targetState 为SHUTDOWN或者 STOP
// 将线程池状态设置为targetState
private void advanceRunState(int targetState) {
// assert targetState == SHUTDOWN || targetState == STOP;
for (;;) {
int c = ctl.get();
if (runStateAtLeast(c, targetState) ||
ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
break;
}
}
// 尝试将线程池terminate
// 非阻塞调用,不满足条件直接返回。这个函数在任何可能terminate的地方都会调用
final void tryTerminate() {
for (;;) {
int c = ctl.get();
//RUNNING态 或者 TIDYING/TERMINATE 或者 SHUTDOWN且workQueue非空
// RUNNING不能直接TERMINATE,处于TIDYING/TERMINATE说明有其他程序已经调用了tryTerminater,
// 而处于SHUTDOWN需要先把workQueue清空
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateLessThan(c, STOP) && ! workQueue.isEmpty()))
return;
//必须所有worker全都先停止
if (workerCountOf(c) != 0) { // Eligible to terminate
interruptIdleWorkers(ONLY_ONE);
return;
}
//mainLock的条件变量,要先加锁
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
//这个函数为一个hook,这个类中为空
terminated();
} finally {
//只有一个线程会执行到这里,所以直接改就完了
ctl.set(ctlOf(TERMINATED, 0));
//通知所有在termination条件等待的线程
termination.signalAll();
}
//完成终止操作
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
//如果存在安全管理器,需要判断一下所有线程的修改权限,保证可以interrupt
private void checkShutdownAccess() {
// assert mainLock.isHeldByCurrentThread();
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(shutdownPerm);
for (java.util.concurrent.ThreadPoolExecutor.Worker w : workers)
security.checkAccess(w.thread);
}
}
//尝试将所有worker中断
private void interruptWorkers() {
// assert mainLock.isHeldByCurrentThread();
for (java.util.concurrent.ThreadPoolExecutor.Worker w : workers)
w.interruptIfStarted();
}
//中断所有空闲的worker,如果onlyOne == True,则只中断至多一个
// onlyOne == True只会在tryTerminate中出现,当其他条件都满足(即处于SHUTDOWN状态,队列已空)但是仍有worker存在时调用。
// tryTerminate中一直循环,这里就不循环做重复判断了,只等第一个worker销毁后再继续。
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
//遍历worker保证workers不被修改
mainLock.lock();
try {
for (java.util.concurrent.ThreadPoolExecutor.Worker w : workers) {
Thread t = w.thread;
// 加锁成功,保证worker没有在执行任务。
if (!t.isInterrupted() && w.tryLock()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
if (onlyOne)
break;
}
} finally {
mainLock.unlock();
}
}
// 默认onlyOne = false,只有tryTerminate会调用onlyOne == true的版本
private void interruptIdleWorkers() {
interruptIdleWorkers(false);
}
private static final boolean ONLY_ONE = true;
//拒绝任务command,掉啊用拒绝执行处理函数
final void reject(Runnable command) {
handler.rejectedExecution(command, this);
}
//一个钩子,shutdown的时候调用
void onShutdown() {
}
// 清空任务队列,并返回队列中的任务
private List<Runnable> drainQueue() {
BlockingQueue<Runnable> q = workQueue;
ArrayList<Runnable> taskList = new ArrayList<>();
q.drainTo(taskList);
//什么时候非空?
if (!q.isEmpty()) {
//toArray会把内容复制到一个Array返回。一个个移除
for (Runnable r : q.toArray(new Runnable[0])) {
if (q.remove(r))
taskList.add(r);
}
}
return taskList;
}
// 尝试增加一个worker,返回增加结果。firstTask 是初始任务,可以是null,core表示是否使用corePoolSize为线程数目上限。
//只有核心线程未满,或者线程池关闭,或者任务队列满才有firstTask != null
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (int c = ctl.get();;) {
//线程池强制关闭等后续状态(stop/tidying/terminated),
//或者处于shutdown但是firstTask 非空 / 队列为空
//当处于shutdown时,不能提交新任务,但是会将workQueue中的任务执行完
//当处于stop等后续状态时,则不会运行任何任务,直接返回false
if (runStateAtLeast(c, SHUTDOWN)
&& (runStateAtLeast(c, STOP)
|| firstTask != null
|| workQueue.isEmpty()))
return false;
for (;;) {
//超过线程数限制,直接返回false
if (workerCountOf(c)
>= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
return false;
//CAS 增加workercount,失败就继续,成功就退出循环
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
//如果状态变成了SHUTDOWN,则需要重试
if (runStateAtLeast(c, SHUTDOWN))
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
// 线程池还没STOP 且 worker计数已经增加了
boolean workerStarted = false;
boolean workerAdded = false;
java.util.concurrent.ThreadPoolExecutor.Worker w = null;
try {
w = new java.util.concurrent.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 c = ctl.get();
//线程池处于RUNNING 或者 SHUTDOWN且firstTast为空(firstTask为空说明task放到队列中了)
if (isRunning(c) ||
(runStateLessThan(c, STOP) && firstTask == null)) {
//为什么要加这个判断? 保证线程工厂产生的线程状态??
if (t.getState() != Thread.State.NEW)
throw new IllegalThreadStateException();
workers.add(w);
workerAdded = true;
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
}
} finally {
mainLock.unlock();
}
//worker加入成功,启动线程
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
//没有启动成功,要么就是worker没有加入,要么调用start异常
//调用addWorkerFailed做一些清理
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
//将worker从workers中移除,尝试终止线程池
private void addWorkerFailed(java.util.concurrent.ThreadPoolExecutor.Worker w) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (w != null)
workers.remove(w);
decrementWorkerCount();
tryTerminate();
} finally {
mainLock.unlock();
}
}
//worker退出后的清理工作,completedAbruptly标识worker是否是因为异常而导致的退出
//
private void processWorkerExit(java.util.concurrent.ThreadPoolExecutor.Worker w, boolean completedAbruptly) {
//如果是异常退出,worker计数没有更新
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
//更新总共完成任务数,移除worker
try {
completedTaskCount += w.completedTasks;
workers.remove(w);
} finally {
mainLock.unlock();
}
tryTerminate();
int c = ctl.get();
// SHUTDOWN or RUNNING
// 如果worker是自然退出的,需要根据设置启动空转的线程。
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
addWorker(null, false);
}
}
//从阻塞队列中获取一个任务
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
// 如果是SHUTDOWN且队列为空,则说明没有任务了
// 如果是STOP以及后续状态,则直接返回。不再执行任务
if (runStateAtLeast(c, SHUTDOWN)
&& (runStateAtLeast(c, STOP) || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// 是否设置超时等待时间,当超时还没有拿到任务,则线程就会终止
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
// wc > maxinumPoolSize || (timed && timeOut && workQueue.isEmpty())
// 上次poll超时,且workQueue仍为空,如果可以退出,尝试退出(避免空转,无意义等待)
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c)) //workercount--成功,则线程终止,否则继续重试
return null;
continue;
}
try {
//直接阻塞等待还是超时阻塞。
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
// 阻塞被中断(interrupt),有线程通过中断唤醒了这个线程,比如改变了allowCoreThreadTimeOut
timedOut = false;
}
}
}
// 真正执行任务的函数,线程的run函数中会调用这个函数。
final void runWorker(java.util.concurrent.ThreadPoolExecutor.Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
//调用unlock函数会将worker的state设成0(运行状态),就允许中断了.(见tryRelease)
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
w.lock();
//当线程池处于stop的后续状态确保wt设置了interrupted
//当线程池处于running或者shutdown状态,确保wt没有被设置interrupted
//调用Thread.interrupted()会设interrupted=false。
//但是有可能第一个判断和第二个判断中间某个线程调用shutdownNow将状态设成STOP
//此时,要重新设置回去,将interrupted设置成true。
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
//beforeExecute和afterExecute都是hook
beforeExecute(wt, task);
try {
task.run();
afterExecute(task, null);
} catch (Throwable ex) {
afterExecute(task, ex);
throw ex;
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
//两种退出情况,一种是run的时候抛出异常(异常情况),另一种是等待任务超时(正常情况)
processWorkerExit(w, completedAbruptly);
}
}
//构造函数1, 使用默认线程工厂和默认任务拒绝异常处理
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
//构造函数2 使用默认的拒绝异常处理
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, defaultHandler);
}
//构造函数3 使用默认线程工厂
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}
//构造函数4 上面的构造函数最终会调用这个构造函数
// 就是将各种参数值保存下来而已
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;
}
// 调用submit提交任务时会调用execute函数,execute函数负责将任务提交给worker。失败时调用拒绝处理方法
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 当线程数小于corePoolSize时,直接尝试创建新的线程,将task交给这个worker
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
// 线程数超过corepoolSize或者addWorker失败
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
//重新检查一下线程池是否还在运行,如果没有则移除并拒绝任务
//如果不重新检查,也不会怎么样吧,只是会增加多余的worker。这里应该是对效率的优化
if (! isRunning(recheck) && remove(command))
reject(command);
// 依旧处于RUNNING状态或者任务移除失败(被取走了?),如果一个worker都没有,则增加一个。始终保持有一个线程存在
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 线程池已经关闭,或者队列已满。从这里可以看出,只有在队列满的情况下,线程数才有超过corePoolSize的可能
else if (!addWorker(command, false))
reject(command);
}
// 尝试停止线程池,SHUTDOWN状态会将队列的任务执行完
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 判断是否有interrupt的权限,没有的话会抛出异常(相当于啥都没做抛了个异常,要么不可关闭,要么等用户线程修改了权限再尝试)。
checkShutdownAccess();
//权限验证成功,将状态设成SHUTDOWN
advanceRunState(SHUTDOWN);
//将所有空闲的worker线程的interrupted设成true
interruptIdleWorkers();
//一个钩子
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
//尝试终止
tryTerminate();
}
// 强制SHUTDOWN(如果可以),没有执行的任务就不执行了,状态改为STOP
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;
}
public boolean isShutdown() {
return runStateAtLeast(ctl.get(), SHUTDOWN);
}
/** Used by ScheduledThreadPoolExecutor. */
boolean isStopped() {
return runStateAtLeast(ctl.get(), STOP);
}
//处于SHUTDOWN和TERMINATED之间的状态,不包括TERMINATED
public boolean isTerminating() {
int c = ctl.get();
return runStateAtLeast(c, SHUTDOWN) && runStateLessThan(c, TERMINATED);
}
public boolean isTerminated() {
return runStateAtLeast(ctl.get(), TERMINATED);
}
//阻塞等待线程池终止,等待超时时间timeout
public boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException {
long nanos = unit.toNanos(timeout);
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
while (runStateLessThan(ctl.get(), TERMINATED)) {
if (nanos <= 0L)
return false;
nanos = termination.awaitNanos(nanos);
}
return true;
} finally {
mainLock.unlock();
}
}
//已过期,JDK11前,这个函数有非空实体
@Deprecated(since="9")
protected void finalize() {}
//下面是一些参数的设置和获取
//除了通过构造函数,还可以通过这个函数设置线程工厂
public void setThreadFactory(ThreadFactory threadFactory) {
if (threadFactory == null)
throw new NullPointerException();
this.threadFactory = threadFactory;
}
public ThreadFactory getThreadFactory() {
return threadFactory;
}
//设置拒绝处理方法
public void setRejectedExecutionHandler(RejectedExecutionHandler handler) {
if (handler == null)
throw new NullPointerException();
this.handler = handler;
}
public RejectedExecutionHandler getRejectedExecutionHandler() {
return handler;
}
//设置corePoolSize,还要清理空闲的worker,或者增加worker。不管也不会怎么样,为了效率上考虑而做的一些处理
public void setCorePoolSize(int corePoolSize) {
if (corePoolSize < 0 || maximumPoolSize < corePoolSize)
throw new IllegalArgumentException();
int delta = corePoolSize - this.corePoolSize;
this.corePoolSize = corePoolSize;
if (workerCountOf(ctl.get()) > corePoolSize)
interruptIdleWorkers();
else if (delta > 0) {
// We don't really know how many new threads are "needed".
// As a heuristic, prestart enough new workers (up to new
// core size) to handle the current number of tasks in
// queue, but stop if queue becomes empty while doing so.
int k = Math.min(delta, workQueue.size());
while (k-- > 0 && addWorker(null, true)) {
if (workQueue.isEmpty())
break;
}
}
}
public int getCorePoolSize() {
return corePoolSize;
}
//预启动一个线程
public boolean prestartCoreThread() {
return workerCountOf(ctl.get()) < corePoolSize &&
addWorker(null, true);
}
//确保至少预启动一个线程,即使corePoolSize == 0
void ensurePrestart() {
int wc = workerCountOf(ctl.get());
if (wc < corePoolSize)
addWorker(null, true);
else if (wc == 0)
addWorker(null, false);
}
//预启动所有核心线程
public int prestartAllCoreThreads() {
int n = 0;
while (addWorker(null, true))
++n;
return n;
}
// 返回是否允许核心线程超时终止,也就是allowCoreThreadTimeOut的值
public boolean allowsCoreThreadTimeOut() {
return allowCoreThreadTimeOut;
}
// 设置allowCoreThreadTimeOut,并且如果值从false改为true,则需要通过interrupt唤醒所有阻塞的线程
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();
}
}
public void setMaximumPoolSize(int maximumPoolSize) {
if (maximumPoolSize <= 0 || maximumPoolSize < corePoolSize)
throw new IllegalArgumentException();
this.maximumPoolSize = maximumPoolSize;
if (workerCountOf(ctl.get()) > maximumPoolSize)
interruptIdleWorkers();
}
public int getMaximumPoolSize() {
return maximumPoolSize;
}
//设置空闲线程存活时间,存活时间比原来的短,需要通过interrupt唤醒阻塞线程
public void setKeepAliveTime(long time, TimeUnit unit) {
if (time < 0)
throw new IllegalArgumentException();
if (time == 0 && allowsCoreThreadTimeOut())
throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
long keepAliveTime = unit.toNanos(time);
long delta = keepAliveTime - this.keepAliveTime;
this.keepAliveTime = keepAliveTime;
if (delta < 0)
interruptIdleWorkers();
}
public long getKeepAliveTime(TimeUnit unit) {
return unit.convert(keepAliveTime, TimeUnit.NANOSECONDS);
}
public BlockingQueue<Runnable> getQueue() {
return workQueue;
}
//从队列移除task,然后尝试终止
public boolean remove(Runnable task) {
boolean removed = workQueue.remove(task);
tryTerminate(); // In case SHUTDOWN and now empty
return removed;
}
//删除所有cancelled的的任务从队列中清除
public void purge() {
final BlockingQueue<Runnable> q = workQueue;
try {
Iterator<Runnable> it = q.iterator();
while (it.hasNext()) {
Runnable r = it.next();
if (r instanceof Future<?> && ((Future<?>)r).isCancelled())
it.remove();
}
} catch (ConcurrentModificationException fallThrough) {
// Take slow path if we encounter interference during traversal.
// Make copy for traversal and call remove for cancelled entries.
// The slow path is more likely to be O(N*N).
for (Object r : q.toArray())
if (r instanceof Future<?> && ((Future<?>)r).isCancelled())
q.remove(r);
}
tryTerminate(); // In case SHUTDOWN and now empty
}
/* 一些统计信息 */
public int getPoolSize() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// Remove rare and surprising possibility of
// isTerminated() && getPoolSize() > 0
return runStateAtLeast(ctl.get(), TIDYING) ? 0
: workers.size();
} finally {
mainLock.unlock();
}
}
// 活跃的worker数目,这个应该不是精确的,因为isLocked只是说明线程在执行任务,事实上worker还可能在取任务
public int getActiveCount() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
int n = 0;
for (java.util.concurrent.ThreadPoolExecutor.Worker w : workers)
if (w.isLocked())
++n;
return n;
} finally {
mainLock.unlock();
}
}
public int getLargestPoolSize() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
return largestPoolSize;
} finally {
mainLock.unlock();
}
}
//获取任务数 = 已经完成的任务数 + 正在执行的任务数 + 队列中的任务数
public long getTaskCount() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
long n = completedTaskCount;
for (java.util.concurrent.ThreadPoolExecutor.Worker w : workers) {
n += w.completedTasks;
if (w.isLocked())
++n;
}
return n + workQueue.size();
} finally {
mainLock.unlock();
}
}
//获取已经完成的任务数
public long getCompletedTaskCount() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
long n = completedTaskCount;
for (java.util.concurrent.ThreadPoolExecutor.Worker w : workers)
n += w.completedTasks;
return n;
} finally {
mainLock.unlock();
}
}
public String toString() {
long ncompleted;
int nworkers, nactive;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
ncompleted = completedTaskCount;
nactive = 0;
nworkers = workers.size();
for (java.util.concurrent.ThreadPoolExecutor.Worker w : workers) {
ncompleted += w.completedTasks;
if (w.isLocked())
++nactive;
}
} finally {
mainLock.unlock();
}
int c = ctl.get();
String runState =
isRunning(c) ? "Running" :
runStateAtLeast(c, TERMINATED) ? "Terminated" :
"Shutting down";
return super.toString() +
"[" + runState +
", pool size = " + nworkers +
", active threads = " + nactive +
", queued tasks = " + workQueue.size() +
", completed tasks = " + ncompleted +
"]";
}
/* 一些钩子扩展 */
protected void beforeExecute(Thread t, Runnable r) { }
protected void afterExecute(Runnable r, Throwable t) { }
protected void terminated() { }
//拒绝处理策略类CallerRunsPolicy,如果任务被拒绝,则由调用线程执行
public static class CallerRunsPolicy implements RejectedExecutionHandler {
public CallerRunsPolicy() { }
public void rejectedExecution(Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
if (!e.isShutdown()) {
r.run();
}
}
}
//拒绝就抛出RejectedExecutionException异常
public static class AbortPolicy implements RejectedExecutionHandler {
/**
* Creates an {@code AbortPolicy}.
*/
public AbortPolicy() { }
public void rejectedExecution(Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
e.toString());
}
}
//直接丢弃,忽略,什么都不做
public static class DiscardPolicy implements RejectedExecutionHandler {
public DiscardPolicy() { }
public void rejectedExecution(Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
}
}
//丢弃队头
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
public DiscardOldestPolicy() { }
public void rejectedExecution(Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
if (!e.isShutdown()) {
e.getQueue().poll();
e.execute(r);
}
}
}
}