Java线程池-ThreadPoolExecutor概述
线程池执行器将会根据corePoolSize和maximumPoolSize自动地调整线程池大小。
当在execute(Runnable)方法中提交新任务并且少于corePoolSize线程正在运行时，即使其他工作线程处于空闲状态，也会创建一个新线程来处理该请求。 如果有多于corePoolSize但小于maximumPoolSize线程正在运行，则仅当队列已满时才会创建新线程。 通过设置corePoolSize和maximumPoolSize相同，您可以创建一个固定大小的线程池。 通过将maximumPoolSize设置为基本上无界的值，例如Integer.MAX_VALUE，您可以允许池容纳任意数量的并发任务。 通常，核心和最大池大小仅在构建时设置，但也可以使用setCorePoolSize和setMaximumPoolSize进行动态更改。
任务在线程池中的处理流程如图：
ThreadFactory
CPU密集型-》CPU核数+1（C+1）
IO密集型-》2倍CPU核数+1）(2C+1)
Ｉ/O密集型适合读写，比如数据库的读写操作，CPU密集型适合运算
/*
*
* 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.
*1. 判断当前线程数是否小于核心线程数，尝试使用addWorker一个新线程作为它的第一个任务如果能完成新 线程创建execute方法结束，成功提交任务
* 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.
* 在第一步没有完成任务提交；状态为运行并且能否成功加入任务到工作队列后，再进行一次check，如果状态
// 在任务加入队列后变为了非运行（有可能是在执行到这里线程池shutdown了），非运行状态下当然是需要
* 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.
* 如果不能加入任务到工作队列，将尝试使用任务新增一个线程，如果失败，则是线程池已经shutdown或者线 程池
// 已经达到饱和状态，所以reject这个他任务
*/
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 工作线程数 < 核心线程数
if (workerCountOf(c) < corePoolSize) {
// 直接启动新线程，true表示会再次检查workerCount是否小于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);
}
- addWorker(command,true)：创建核心线程执行任务；
- addWorker(command,false)：创建非核心线程执行任务；
- addWorker(null,false)：创建非核心线程，当前任务没空
private boolean addWorker(Runnable firstTask, boolean core) {
// 第一部分：自旋、CAS、重读ctl 等结合，直到确定是否可以创建worker，
// 可以则跳过循环继续操作，否则返回false
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount(c))// CAS增长workerCount，成功则跳出循环
break retry;
c = ctl.get(); // Re-read ctl 重新获取ctl
if (runStateOf(c) != rs)// 状态改变则继续外层循环，否则在内层循环
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
// 第二部分：创建worker，这部分使用ReentrantLock锁
boolean workerStarted = false; // 线程启动标志位
boolean workerAdded = false; //线程是否加入workers 标志位
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.
// 获取到锁以后仍需检查ctl，可能在上一个获取到锁处理的线程可能会改变runState
// 如 ThreadFactory 创建失败 或线程池被 shut down等
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);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start(); // 启动线程
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w); // 失败操作
}
return workerStarted;
}
addWorker的工作可分为两部分：
- 第一部分：原子操作，判断是否可以创建worker，通过自旋、CAS、ctl操作，判断继续创建还是返回false，自旋周期一般很短。
- 第二部分：同步创建workder，并启动线程。
private final class Worker extends AbstractQueuedSynchronizer implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
/** 每个worker有自己的内部线程，ThreadFactory创建失败时是null */
final Thread thread;
/** 初始化任务，可能是null */
Runnable firstTask;
/** 每个worker的完成任务数 */
volatile long completedTasks;
Worker(Runnable firstTask) {
setState(-1); // 禁止线程在启动前被打断
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
/** 重要的执行方法 */
public void run() {
runWorker(this);
}
// state = 0 代表未锁；state = 1 代表已锁
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;
}
public void lock() { acquire(1); }
public boolean tryLock() { return tryAcquire(1); }
public void unlock() { release(1); }
public boolean isLocked() { return isHeldExclusively(); }
// interrupt已启动线程
void interruptIfStarted() {
Thread t;
// 初始化是 state = -1，不会被interrupt
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
Worker 实现了简单的 非重入互斥锁，互斥容易理解，非重入是为了避免线程池的一些控制方法获得重入锁，比如setCorePoolSize操作。注意 Worker 实现锁的目的与传统锁的意义不太一样。其主要是为了控制线程是否可interrupt，以及其他的监控，如线程是否 active（正在执行任务）。
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // 允许被 interrupt
boolean completedAbruptly = true;
try {
// loop 直至 task = null （线程池关闭、超时等）
// 注意这里的getTask()方法，我们配置的阻塞队列会在这里起作用
while (task != null || (task = getTask()) != null) {
w.lock(); // 执行任务前上锁
// 如果线程池停止，确保线程中断; 如果没有，确保线程不中断。这需要在第二种情况下进行重新获取ctl，以便在清除中断时处理shutdownNow竞争
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(); // 真正执行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); // 线程退出工作
}
}
