ThreadPoolExecutor源码剖析
一、Java构建线程的方式
- 继承Thread（也是实现的Runnable接口）
- 实现Runnable
- 实现Callable
- 线程池方式（可以实现以上兼容）
- Java提供了Executors可以创建（阿里规约不允许直接创建线程池）
- 推荐手动创建线程池（new ThreadPoolExecutor的方式）
二、线程池的7个参数
public ThreadPoolExecutor(int corePoolSize,//线程池的核心线程数量
int maximumPoolSize,//线程池的最大线程数
long keepAliveTime,//当线程数大于核心线程数时，多余的空 闲线程存活的最长时间
TimeUnit unit,//时间单位
BlockingQueue<Runnable> workQueue,//任务队列，用来储 存等待执行任务的队列
ThreadFactory threadFactory,//线程工厂，用来创建线程， 一般默认即可
RejectedExecutionHandler handler//拒绝策略，当提交的 任务过多而不能及时处理时，我们可以定制策略来处理任务
)
三、线程池的执行流程
为什么要先进行阻塞在去尝试创建非核心线程：
**举例解释：**饭店（线程池）-厨子（线程）-排队（阻塞）、招厨子（创建线程）？-今日客满（拒绝策略）
四、线程池的属性标识
4.1、线程池的核心属性
//ct1:1:声明当前线程池的状态，2：声明当前线程池中的线程数
//高3位：线程池状态，低29位是：线程池中的线程个数
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;//29，方便后面做位运算
private static final int CAPACITY = (1 << COUNT_BITS) - 1;//通过位运算得出最大容量
// runState is stored in the high-order bits
private static final int RUNNING = -1 << COUNT_BITS;//111 代表正常接受任务
private static final int SHUTDOWN = 0 << COUNT_BITS;//000 代表不接受新任务，但还会处理内部阻塞队列中的任务，正在进行的任务也正常处理
private static final int STOP = 1 << COUNT_BITS;//001 代表线程池立马停止，不接受新任务，不处理阻塞队列中的任务，同时终端执行中的任务
private static final int TIDYING = 2 << COUNT_BITS;//010 代表过渡状态，代表当前线程池即将结束
private static final int TERMINATED = 3 << COUNT_BITS;//011 代表线程池为TREMINATED，线程池已经结束
// Packing and unpacking ctl
private static int runStateOf(int c) { return c & ~CAPACITY; }//得到线程池的状态
private static int workerCountOf(int c) { return c & CAPACITY; }//得到当前线程池的线程数
private static int ctlOf(int rs, int wc) { return rs | wc; }//获取ctl
4.2、线程池的状态变化
五、线程池的exectute方法
从execute方法开始（对应4.2的线程变化图）：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
*
* 2. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
*
* 3. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
*/
//拿到32位的int
int c = ctl.get();
//工作线程数 < 核心线程数
if (workerCountOf(c) < corePoolSize) {
//进入if，代表可以创建 核心 线程数
if (addWorker(command, true))
//在此结束
return;
//如果没进入if，代表创建核心线程数失败，重新获取 ctl
c = ctl.get();
}
//判断线程池为Running状态，将任务添加入阻塞队列
if (isRunning(c) && workQueue.offer(command)) {
//在此获取ctl
int recheck = ctl.get();
//再次判断是否为Running状态，若不是Running状态，remove任务
if (! isRunning(recheck) && remove(command))
reject(command);
//如果线程池在Running状态，线程池数量为0
else if (workerCountOf(recheck) == 0)
//阻塞队列有任务，但是没有工作线程，添加一个任务为空的工作线程处理阻塞队列中的任务
addWorker(null, false);
}
//阻塞队列已满，创建非核心线程，拒绝策略
else if (!addWorker(command, false))
reject(command);
}
通过上述源码，线程池的执行流程，同4.2，以下将进行addWorker方法
六、addWorker方法剖析
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
//获取ctl
int c = ctl.get();
//获取线程池状态
int rs = runStateOf(c);
// Check if queue empty only if necessary.
//除了RUNNING的其他状态
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN && firstTask == null &&! workQueue.isEmpty())
//rs==SHUTDOWN，如果不是SHUTDOWN，就代表是STOP或者更高的状态，此时不需要添加线程处理任务
//任务为空，，如果任务为null,并且线程池状态不是RUNNING，不需要处理
//阻塞队列不为null，如果阻塞队列为空，返回flase，取反，获取true，不需要处理
)
//创建工作线程失败
return false;
for (;;) {
//获取工作线程个数
int wc = workerCountOf(c);
if (wc >= CAPACITY ||//如果当前线程大于线程池最大容量，不创建线程
//判断wc是否超过核心线程或者最大线程数
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//将工作线程数+1，采用CAS的方式
if (compareAndIncrementWorkerCount(c))
//成功退出外侧for循环
break retry;
c = ctl.get(); // Re-read ctl
//判断线程池状态，如果有变化；如果没变化，走内侧循环
if (runStateOf(c) != rs)
//continue外侧循环
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
//Worker为工作线程
Worker w = null;
try {
w = new Worker(firstTask);
//从Worker中获取线程t
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());
//线程状态为RUNNING状态
if (rs < SHUTDOWN ||
//是SHUTDOWN状态，创建空任务工作线程，先处理阻塞队列中的任务
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
//将工作线程添加到集合（hashSet）中
workers.add(w);
//获取工作线程个数
int s = workers.size();
//如果线程工作线程数，大于之前记录的最大线程数，做替换操作
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;//添加工作线程成功
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();//启动工作线程
workerStarted = true;//启动工作线程成功
}
}
} finally {
//如果启动工作线程失败，调用addWorkerFailed方法
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;//返回工作线程启动
}
七、Worker的封装
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
/**
* This class will never be serialized, but we provide a
* serialVersionUID to suppress a javac warning.
*/
private static final long serialVersionUID = 6138294804551838833L;
/** Thread this worker is running in. Null if factory fails. */
final Thread thread;
/** Initial task to run. Possibly null. */
Runnable firstTask;
/** Per-thread task counter */
volatile long completedTasks;
/**
* Creates with given first task and thread from ThreadFactory.
* @param firstTask the first task (null if none)
*/
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
/** Delegates main run loop to outer runWorker */
public void run() {
runWorker(this);
}
runWorker方法：
final void runWorker(Worker w) {
//获取当前线程
Thread wt = Thread.currentThread();
//拿到任务
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
//任务不为空，执行任务；如果任务为空，通过getTask从阻塞队列中获取任务！
while (task != null || (task = getTask()) != null) {
w.lock();//枷锁，避免shutdown，任务也不会中单
// 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
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();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
可以继续深入getTask方法，以及processWorkerExit方法
未完待续