目录
线程池创建流程图
源码分析
线程池核心类：ThreadPoolExecutor，其构造方法维护了很多线程池关键参数，比如：corePoolSize、workQueue、handler等等，其都是ThreadPoolExecutor类的成员变量。
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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}另外还有不可忽视的一个属性：workers，这个Set集合就是我们所说的线程池，里面的每一个Worker就是一个工作线程，而线程为什么可以复用，都与这个Worker息息相关。
private final HashSet<Worker> workers = new HashSet<Worker>();下面来看Worker类
- 发现其继承了AQS
- 实现了Runnable接口，代表Worker中一定有一个run方法来执行任务
- 构造方法中this.thread = getThreadFactory().newThread(this);代表启动线程工厂创建一个线程，而入参this代表Worker，于是只要该thread被启动，Worker的run方法就会被执行。
public class ThreadPoolExecutor extends AbstractExecutorService {
private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
// 当前Worker的具体工作线程
final Thread thread;
// 刚提交过来的Runnable任务，可能是核心线程的也可能是最大线程的
// 此Worker之后可能会消费队列中的任务
Runnable firstTask;
// 构造方法初始化以上两个参数
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
...
}
}下面来看threadPoolExecutor.execute方法
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 如果当前工作线程数 < 核心线程数，则创建一个核心Worker，并把任务传递给Worker
if (workerCountOf(c) < corePoolSize) {
// addWorker方法第二个参数如果是true代表是核心线程
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);
}
// 当队列也满了，则开始创建最大线程数（临时Worker）
else if (!addWorker(command, false))
// addWorker = false说明最大线程数满了，则开始执行丢弃策略
reject(command);
}addWorker方法，用于new Worker，一个Worker维护一个Thread。每来一个Runnable任务，都会赋值一个firstTask，因为只有创建核心线程和最大线程的Worker才会走此方法，因此firstTask可能是核心线程的也可能是最大线程的Runnable，创建出来后添加到workers的Set集合，然后调用Worker维护的Thread.start开启线程。
/**
* 添加Worker，一个Worker维护一个Thread
*
* @param firstTask 每来一个Runnable任务，都会赋值一个firstTask
* 当任务数量少于corePoolSize时，Worker会发生复用
*
* @param core 是否创建核心线程
* @return true if successful
*/
private boolean addWorker(Runnable firstTask, boolean core) {
/**
* 上半部分：通过自旋+CAS方式增加Worker数量
*/
retry:
// 外层自旋 检测线程的可用状态
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
// 内层自旋
for (;;) {
int wc = workerCountOf(c);// 获取当前工作线程的数量
// worker数量超过容量直接返回false
// core=true看是否大于核心线程数，否则看是否大于最大线程数；大于了返回false
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// CAS增加Worker数量
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get();
// 线程状态发生改变，外层重新自旋
if (runStateOf(c) != rs)
continue retry;
}
}
/**
* 下半部分：ReentrantLock加锁，创建Worker
*/
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// Worker继承了AQS，实现了Runnable，因此重写run方法
// 而Runnable的run方法执行是通过start方法
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive())
throw new IllegalThreadStateException();
// 把创建出来的Worker添加到workers的Set集合
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();// 启动Worker线程，执行Worker类的run方法
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}thread.start调用的Worker中的run方法，run方法又调用了runWorker方法
public void run() {
runWorker(this);
}死循环中是线程复用的关键参数！
while (task != null || (task = getTask()) != null)遵循短路原则
task是从Worker中获取，而Worker中包含核心线程及非核心线程，但不包含队列中的线程。因此首先执行核心线程及非核心线程中的任务，当这俩执行完了，才会从队列中取。
第一次执行完task后，finally中会将task清空，于是getTask方法从队列中获取任务，因此只要线程池中或者队列中有任务，Worker就会一直执行。而第二次从getTask中获取任务，依然使用的上一次Worker中的task，从而实现了线程复用。
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 ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
// Runnable task调用run方法而不是start方法，实际上并没有开启新的线程
// 最终调用的就是我们自己代码中重写的run方法
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方法从任务队列中获取任务，
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())) {
// CAS操作-1
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;
}
}
}总结【精华】
- 线程池任务提交流程：execute-->创建Worker-->worker.thread.start()-->Wroker.run()-->runWorker-->worker.firstTask.run()
- ThreadPoolExecutor维护了一个Set的workers集合，就是我们所说的线程池，每一个Worker维护了一个工作线程，workers.size即当前threadPool的size
- Worker类实现了Runnable接口，Worker的构造方法中this.thread = getThreadFactory().newThread(this);代表启动线程工厂创建一个线程，而入参this代表Worker，于是只要该thread被启动，Worker的run方法就会被执行。
- 最终执行Worker会首先执行其firstTask，执行之后把task清空，然后从队列中获取，仍然用Worker维护的task来执行run方法，因为run方法不是start，不会开启新的线程，且Worker未做改变，实现了线程复用
- 关于执行顺序：首先addWroker核心线程并执行，超过之后开始入队，刚刚的Worker执行完核心任务后从队列中继续获取任务执行。此时如果继续入队，并且队列已满，则会addWorker临时线程并执行（临时Worker相较于先前的队列中任务属于插队执行，但并不是严格的插队，取决于队首元素进入核心Worker的速度），刚刚执行最大线程的Worker继续从队列中获取任务，因此执行的先后顺序并不绝对，但大概顺序是：核心线程任务-->最大线程任务-->队列任务
常见问题
若corePoolSize=10，maxinumPoolSize=20，queueSize=10;一次性来了30个线程，其执行顺序是如何？
1-10进入核心线程，11-20进入队列，21-30进入最大线程；
首先执行1-10的核心线程，其次执行21-30的最大线程，最后执行11-20队列中的线程。【具体见总结5】
656
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
