You have a dream, you got to protect it. People can't do something by themselves; they wanna tell you you can not do it. You want something. Go get it！
先想是不是，再问为什么！
上一篇文章笔者已经对Excecutor线程池体系进行了简单的阐述，本文将对开发中常用到的ThreadPoolExcecutor原理进行解读，同时也将说明为何不直接使用现有的线程池创建线程？
前文中笔者已经将线程池执行的任务逻辑和线程池参数关系画出，在本文中笔者使用一个新图来梳理下主线程与执行任务线程以及线程池之间的关系
步骤：调用ThreadPoolExcecutor的executor（）方法提交线程，判断核心线程池中已使用的线程大小：如果已使用小于核心线程池大小，创建一个线程；如果已使用线程已经等于核心线程池大小，将线程加入到阻塞队列中（这里需要再次判断：如果阻塞队列未满，放入到阻塞队列，否则将启动拒绝策略）。注意线程池是否有最大线程数，若有则需考虑，在核心线程池试用完，使用最大线程池，同时判断最大线程池的使用情况。上述讨论都是线程执行未释放，如果已经释放，则直接从阻塞队列中拉取线程执行。
ThreadPoolExcecutor的构造方法
构造方法参数：
核心线程数 corePoolSize
最大线程数maximumPoolSize
非核心线程空闲存活时间keepAliveTime
时间单位 unit
线程池所用缓冲队列workQueue
拒绝策略 RejectedExecutionHandler
异常分析：
if (corePoolSize < 0 ||//如果核心小于0，抛出异常
maximumPoolSize <= 0 ||//如果最大线程小于等于0，抛出异常
maximumPoolSize < corePoolSize ||//如果最大线程数小于核心线程数，抛出异常
keepAliveTime < 0)//如果空闲时间小于0，抛出异常
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)//如果阻塞队列null，线程工厂为null，拒绝策略为null，抛出异常
throw new NullPointerException();线程执行方法executor（）
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);
}
1.如果正在运行的线程少于corePoolSize线程，请尝试执行以下操作：
*以给定命令作为第一个线程来启动新线程任务。
对addWorker的调用自动检查runState和 workerCount，因此可以防止假警报的增加
在不应该执行的情况下通过返回false进行线程化。
2.如果任务可以成功排队，那么我们仍然需要
*仔细检查我们是否应该添加线程
（因为现有的自上次检查后死亡）或自从进入此方法以来，该池已关闭。 所以我们
重新检查状态，并在必要时回退排队停止，如果没有，则启动一个新线程。
3.如果我们无法将任务排队，那么我们尝试添加一个新的线程。
如果失败，我们知道我们已经关闭或饱和并因此拒绝任务。执行方法 addWorker（）方法
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c); // Check if queue empty only if necessary.
if (rs >= SHUTDOWN && //当前线程状态大于SHUTDOWN
! (rs == SHUTDOWN && //当前线程状态等于SHUTDOWN
firstTask == null && //加入的task是null
! workQueue.isEmpty())) //队列不为空
return false; //如果当前线程状态大于SHUTDOWN,不可以增加新的任务；当前线程状态等于SHUTDOWN //不可以增加为空值的task，当队列为空时不增加任务，不为空可以增加为空的task
for (;;) {
int wc = workerCountOf(c);
if (wc >= CAPACITY ||//worker大于等于容量
wc >= (core ? corePoolSize : maximumPoolSize))//worker大于或者等于核心池数量或者最大线程数
return false;
if (compareAndIncrementWorkerCount(c))//使用了CAS算法
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);//新建一个worker
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);//hashSet
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();//执行线程的start（）
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
---------------------------------------------------------------------------------------
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);//新一个线程
}
public void run() {
runWorker(this);
}
---------------------------------------------------------------------------------------
private void addWorkerFailed(Worker w) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (w != null)
workers.remove(w);
decrementWorkerCount();
tryTerminate();
} finally {
mainLock.unlock();
}
}
--------------------------------------------------------------------------------------
public synchronized void start() {
if (threadStatus != 0)
throw new IllegalThreadStateException();
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
}
}
}
----------------------------------------------------------------------------------
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
w.lock();
// 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);
}
}
-------------------------------------------------------------------------------------
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);
// Are workers subject to culling?
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()方法
checkShutdownAccess(); //检查线程状态
-----------------------------------------------------------------------------------------
private void checkShutdownAccess() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(shutdownPerm);
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers)
security.checkAccess(w.thread);
} finally {
mainLock.unlock();
}
}
}
-----------------------------------------------------------------------------------------
advanceRunState(SHUTDOWN);//设置线程状态为shutdown
-----------------------------------------------------------------------------------------
private void advanceRunState(int targetState) {
for (;;) {
int c = ctl.get();
if (runStateAtLeast(c, targetState) ||
ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
break;
}
}
----------------------------------------------------------------------------------------
interruptIdleWorkers();
----------------------------------------------------------------------------------------
private void interruptIdleWorkers() {
interruptIdleWorkers(false);
}
-----------------------------------------------------------------------------------------
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();
}
}
--------------------------------------------------------------------------------------
tryTerminate();
---------------------------------------------------------------------------------------
final void tryTerminate() {
for (;;) {
int c = ctl.get();
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
if (workerCountOf(c) != 0) { // Eligible to terminate
interruptIdleWorkers(ONLY_ONE);
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
terminated();
} finally {
ctl.set(ctlOf(TERMINATED, 0));
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
执行shutdownNow()方法
checkShutdownAccess();
advanceRunState(STOP);
interruptWorkers();
tryTeyminate();
tasks = drainQueue();
------------------------------------------------------------------------------------------
private List<Runnable> drainQueue() {
BlockingQueue<Runnable> q = workQueue;
ArrayList<Runnable> taskList = new ArrayList<Runnable>();
q.drainTo(taskList);
if (!q.isEmpty()) {
for (Runnable r : q.toArray(new Runnable[0])) {
if (q.remove(r))
taskList.add(r);
}
}
return taskList;
}
本文要是有遗漏的地方，我将在评论区给出，同时若读者发现本文不当之处也请在评论区指出，共同研究。
