ThreadPoolExecutor
public class ThreadPoolExecutor extends AbstractExecutorService {
//高3位表示线程状态，后29位线程池大小
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//32-3 = 29
private static final int COUNT_BITS = Integer.SIZE - 3;
//左移29位-1 高3位000 后29全是1
private static final int COUNT_MASK = (1 << COUNT_BITS) - 1;
// 10000000 00000000 00000000 00000001 ~
//11111111 11111111 11111111 11111110 +1
//11111111 11111111 11111111 11111111 <<29
//11100000 00000000 00000000 00000000 +1
//11100000 00000000 00000000 00000001 ~
//10011111 11111111 11111111 11111110 =
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;
//保留高3位
private static int runStateOf(int c) { return c & ~COUNT_MASK; }
//保留低29位
private static int workerCountOf(int c) { return c & COUNT_MASK; }
//合并
private static int ctlOf(int rs, int wc) { return rs | wc; }
//线程池是否正在运行
private static boolean isRunning(int c) {
return c < SHUTDOWN;
}
//corePoolSize 核心线程
//maximumPoolSize 最大线程数
//keepAliveTime 空闲线程存活时间
//workQueue 线程队列
//threadFactory 线程工厂
//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.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
}
execute 提交任务
public void execute(Runnable command) {
//获取线程池状态/线程数量
int c = ctl.get();
//线程数量是否小于核心线程数
if (workerCountOf(c) < corePoolSize) {
//添加核心线程执行core = true
//false 线程池关闭/线程数超过核心线程数...
if (addWorker(command, true))
return;
c = ctl.get();
}
//线程池正在运行 && 成功添加线程队列
if (isRunning(c) && workQueue.offer(command)) {
//重新计算线程状态
int recheck = ctl.get();
//1.线程池不在是运行状态
//线程队列删除成功 走拒绝策略
//删除失败，线程池==0 创建空闲线程
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//线程池非运行状态 或者 队列已满
//尝试创建非核心线程
//线程池状态大于等于SYTOP,或者线程数大于等于最大线程数添加失败走拒绝策略
else if (!addWorker(command, false))
reject(command);
}
remove
- task已经被执行，移除失败
- 有些队列不支持移除task
- 线程池关闭，
public boolean remove(Runnable task) {
boolean removed = workQueue.remove(task);
//线程池处于SHUTDOWN 并且队列为空，尝试终止线程池
tryTerminate(); // In case SHUTDOWN and now empty
return removed;
}
addWorker 创建线程
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (int c = ctl.get();;) {
//1.线程池关闭或者停止，
//2.任务不为空 或者 队列为空
//拒绝添加工作线程
//比如调用shutdown()
if (runStateAtLeast(c, SHUTDOWN)
//>= STOP
&& (runStateAtLeast(c, STOP)
|| firstTask != null
|| workQueue.isEmpty()))
return false;
for (;;) {
//检查线程是否超过了限制
if (workerCountOf(c)
>= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
return false;
//尝试增加工作线程
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
//>= SHIURDOWN 线程池状态变化，重新循环
if (runStateAtLeast(c, SHUTDOWN))
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
//创建Worker对象
w = new Worker(firstTask);
//获取线程对象
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
int c = ctl.get();
//1.处于运行状态
//2.线程未停止&&firstTask == null
//3.Thread对象处于NEW状态，未被启动
// (1 || 2) && 将worker添加到工作线程集合中
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();
}
//添加成功，启动线程
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
//清理失败的工作线程
addWorkerFailed(w);
}
return workerStarted;
}
Worker
Worker实现了Runnable接口，相当于Thread的runnable,当Thread.start()会执行Worker里的run方法。- Worker又继承
AbstractQueuedSynchronizer(AQS)相当于一个锁，重写了tryAcquire/tryRelease使Worker实现了不可重入特性，是一个独占锁。 - 任务开始加锁，结束时解锁，通过State锁状态来判断线程是否在运行
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
final Thread thread;
Runnable firstTask;
volatile long completedTasks;
Worker(Runnable firstTask) {
//未开始 锁状态 -1
setState(-1);
this.firstTask = firstTask;
//线程工厂创建线程，并传入Worker作为runnable
this.thread = getThreadFactory().newThread(this);
}
//线程运行
public void run() {
runWorker(this);
}
//是否加锁
//true 表示锁被占了
protected boolean isHeldExclusively() {
return getState() != 0;
}
//尝试获取锁
//只有当State = 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(); }
//线程中断请求
//1.线程已经启动过
//2.线程未被中断
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
runWorker(this)
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
//先解锁，state = 0 表示线程正在运行，线程可以中断
w.unlock();
boolean completedAbruptly = true;
try {
//task不为空，或者从线程队列里取task
while (task != null || (task = getTask()) != null) {
w.lock();
//1.1线程池状态大于停止 或者
//1.2当前线程中断，并且线程池状态大于停止
//2.并且线程没有中断
//中断线程
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
//钩子函数，返回当前执行的线程和task
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 {
processWorkerExit(w, completedAbruptly);
}
}
getTask() 核心线程不回收的奥秘
private Runnable getTask() {
//超时标识
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
//1.>= STOP 返回null 对应 shutdownNow() 后面详细分析
//2.>= SHUTDOWN && 线程队列为空 返回null 对应shutdown()
//
if (runStateAtLeast(c, SHUTDOWN)
&& (runStateAtLeast(c, STOP) || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
//获取线程数量
int wc = workerCountOf(c);
//1.运行回收核心线程
//2.线程数量大于核心线程数
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//1.线程数超过限制
//2.运行回收线程并且超过空闲时间
//两个满足一个并且 线程数大于1 或者 线程队列为空，尝试回收线程
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
//take()如果队列为空，一直阻塞
//poll(,)如果队列为空，则阻塞等待指定的超时时间
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
//走到这里说明pool()获取超时，下次循环查看是否回收
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
shutdown
已提交的任务和线程队列里的任务执行，后续提交的新任务走拒绝策略
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
//设置当前状态为SHUTDOWN
advanceRunState(SHUTDOWN);
//回收空闲线程
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
tryTerminate();
}
interruptIdleWorkers()
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//循环遍历工作线程的结合
for (Worker w : workers) {
Thread t = w.thread;
//1.线程没有被中断
//2.并且tryLock加锁成功（任务不在：还未执行或者还在执行阶段）才能中断
if (!t.isInterrupted() && w.tryLock()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
if (onlyOne)
break;
}
} finally {
mainLock.unlock();
}
}
shutdownNow
正在运行的任务尝试终止，线程队列里的任务不会执行，作为返回值返回，新加入的任务走拒绝策略
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
private void interruptWorkers() {
//
for (Worker w : workers)
//尝试中断线程
w.interruptIfStarted();
}
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
tryTerminate
尝试终止线程池
final void tryTerminate() {
for (;;) {
int c = ctl.get();
//1.线程池正在运行
//2。或者已经处于TIDYING，TERMINATED
//3.线程池未停止，并且队列不为空
//上述三者都不会执行终止逻辑
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateLessThan(c, STOP) && ! workQueue.isEmpty()))
return;
//线程数量不为0，尝试中断一个空闲线程
if (workerCountOf(c) != 0) { // Eligible to terminate
interruptIdleWorkers(ONLY_ONE);
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//将线程池的状态TIDYING，线程数量为0
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
}
}
awaitTermination(timeout,)
用于等待线程池终止。它会阻塞当前线程，直到线程池中的所有任务执行完成并且线程池状态变为 TERMINATED，或者等待超时
- 如果线程池在指定时间内终止，返回
true。 - 如果超时后线程池仍未终止，返回
false。
