线程池实现分析
线程池，主要是用来重复使用线程，省去每次任务都去创建线程这个开销。
这样一说，最简单的实现就是 run 方法了吗一个死循环，然后从阻塞队列里面获取任务执行。
其实大体思路是这样，我们看一下 JDK 线程池的具体实现。
知道了他是怎样实现的，我们就知道了他的不足，以及如何扩展。
最简单的创建线程池的方法就是 Executors.new** 方法，Executors 是一个线程池相关的工具类，我们进到里面看，创建普通线程池就是 ThreadPoolExecutor 类
创建定时线程池就是 ScheduledThreadPoolExecutor 类，
ThreadPoolExecutor
我们先看普通线程池的实现
接口体系很简单
Executor
只有一个 execute 方法，用来执行任务。
public interface Executor {
void execute(Runnable command);
}ExecutorService
添加了关闭线程池相关的方法，还有 submit 方法，这个方法主要是针对返回 Future 的调用，还有 invoke 系列方法，执行部分或者全部给定任务，用的比较少
public interface ExecutorService extends Executor {
void shutdown();
List<Runnable> shutdownNow();
boolean isShutdown();
boolean isTerminated();
boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;
<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException;
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException;
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException;
<T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}接着就是一个抽象实现 AbstractExecutorService
public abstract class AbstractExecutorService implements ExecutorService {
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Runnable task, T result) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task, result);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
boolean timed, long nanos)
throws InterruptedException, ExecutionException, TimeoutException {
if (tasks == null)
throw new NullPointerException();
int ntasks = tasks.size();
if (ntasks == 0)
throw new IllegalArgumentException();
ArrayList<Future<T>> futures = new ArrayList<Future<T>>(ntasks);
ExecutorCompletionService<T> ecs =
new ExecutorCompletionService<T>(this);
// For efficiency, especially in executors with limited
// parallelism, check to see if previously submitted tasks are
// done before submitting more of them. This interleaving
// plus the exception mechanics account for messiness of main
// loop.
try {
// Record exceptions so that if we fail to obtain any
// result, we can throw the last exception we got.
ExecutionException ee = null;
final long deadline = timed ? System.nanoTime() + nanos : 0L;
Iterator<? extends Callable<T>> it = tasks.iterator();
// Start one task for sure; the rest incrementally
futures.add(ecs.submit(it.next()));
--ntasks;
int active = 1;
for (;;) {
Future<T> f = ecs.poll();
if (f == null) {
if (ntasks > 0) {
--ntasks;
futures.add(ecs.submit(it.next()));
++active;
}
else if (active == 0)
break;
else if (timed) {
f = ecs.poll(nanos, TimeUnit.NANOSECONDS);
if (f == null)
throw new TimeoutException();
nanos = deadline - System.nanoTime();
}
else
f = ecs.take();
}
if (f != null) {
--active;
try {
return f.get();
} catch (ExecutionException eex) {
ee = eex;
} catch (RuntimeException rex) {
ee = new ExecutionException(rex);
}
}
}
if (ee == null)
ee = new ExecutionException();
throw ee;
} finally {
for (int i = 0, size = futures.size(); i < size; i++)
futures.get(i).cancel(true);
}
}
public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException {
try {
return doInvokeAny(tasks, false, 0);
} catch (TimeoutException cannotHappen) {
assert false;
return null;
}
}
public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
return doInvokeAny(tasks, true, unit.toNanos(timeout));
}
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException {
if (tasks == null)
throw new NullPointerException();
ArrayList<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
boolean done = false;
try {
for (Callable<T> t : tasks) {
RunnableFuture<T> f = newTaskFor(t);
futures.add(f);
execute(f);
}
for (int i = 0, size = futures.size(); i < size; i++) {
Future<T> f = futures.get(i);
if (!f.isDone()) {
try {
f.get();
} catch (CancellationException ignore) {
} catch (ExecutionException ignore) {
}
}
}
done = true;
return futures;
} finally {
if (!done)
for (int i = 0, size = futures.size(); i < size; i++)
futures.get(i).cancel(true);
}
}
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException {
if (tasks == null)
throw new NullPointerException();
long nanos = unit.toNanos(timeout);
ArrayList<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
boolean done = false;
try {
for (Callable<T> t : tasks)
futures.add(newTaskFor(t));
final long deadline = System.nanoTime() + nanos;
final int size = futures.size();
// Interleave time checks and calls to execute in case
// executor doesn't have any/much parallelism.
for (int i = 0; i < size; i++) {
execute((Runnable)futures.get(i));
nanos = deadline - System.nanoTime();
if (nanos <= 0L)
return futures;
}
for (int i = 0; i < size; i++) {
Future<T> f = futures.get(i);
if (!f.isDone()) {
if (nanos <= 0L)
return futures;
try {
f.get(nanos, TimeUnit.NANOSECONDS);
} catch (CancellationException ignore) {
} catch (ExecutionException ignore) {
} catch (TimeoutException toe) {
return futures;
}
nanos = deadline - System.nanoTime();
}
}
done = true;
return futures;
} finally {
if (!done)
for (int i = 0, size = futures.size(); i < size; i++)
futures.get(i).cancel(true);
}
}
}这个抽象类首先加了两个 newTaskFor 方法，用来将 runnable 和 callable 方法包装成一个 FutureTask
FutureTask是 RunnableFuture 的实现。他包装 callbale（runnable 用适配器包装）。然后可以管理 Future
然后 实现了submit 方法，内部都是调用 newTaskFor 然后调用 execute 方法，返回 Future
最后，实现了 invoke系列方法。
可以看到 invokeAny 调用的是 doInvokeAny 方法。这个方法里面使用 ExecutorCompletionService 。他里面有个内部类实现
private class QueueingFuture extends FutureTask<Void> {
QueueingFuture(RunnableFuture<V> task) {
super(task, null);
this.task = task;
}
protected void done() { completionQueue.add(task); }
private final Future<V> task;
}看到，当任务执行完成后添加到了阻塞队列中了。然后调用 poll 就可以获取结果，知道了这个后，再看 doInvokeAny 方法就清楚了多。
就是先调用第一个任务，然后进到循环，如果看有没有返回值，没有的话，就依次提交所有任务，然后等待阻塞队列返回结果，获取到了就返回，然后取消所有任务。
invokeAll 的逻辑就简单了。自己看看就行了，重点在于 execute 方法，我们可以看到还剩下关闭方法和 execute 方法没有实现，是在 ThreadPoolExecutor 类中实现的。
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);
}就是3步：
1. 判断当前工作线程是否 > 核心线程数，如果小于，那就添加工作线程，这个任务作为第一个任务，添加工作线程可能失败。
2. 如果线程池正在执行状态（你没调用 shutdown方法），那就添加任务到队列。后面还有一些检查，如果这个时候线程池关闭了，就移除任务，拒绝，或者工作线程数量为0，那就添加一个工作线程。
3. 如果添加失败了，就再尝试添加工作线程，如果还是失败，执行拒绝策略。
上面的 ctl 是 AtomicInteger 类型，工作线程数量，线程池状态都是有这个字段表示，高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 &&
! (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))
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);
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);
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;
}上面那一坨 for 循环主要是判断状态和数量是否超了，如果正常，就工作线程数量+1，继续下面的逻辑
下面就是 new 一个 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);
}
// Lock methods
//
// The value 0 represents the unlocked state.
// The value 1 represents the locked state.
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(); }
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}我们可以看到内部 thread 字段就是具体的线程实例，外部也是调用这个实例的 start 方法启动线程的。
thread 包装的 runnable 是 this，也就是本 worker，worker 的 run 方法是调用外部的 runWorker。
线程实例的构建调用了 getThreadFactory 获取线程工厂来构造的。Worker 还继承了 AQS ，这个就不将了。
先简单说一下 getThreadFactory 这个方法，他获取的是 ThreadFactory 的实现。
这里 runnable 传的参数可以看到就是 worker 本身。这个 ThreadFactory 可以自己实现，通常自己实现都是加上线程名。或者是否为后台线程。
public interface ThreadFactory {
Thread newThread(Runnable r);
}在说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 {
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);
}
}这个稍微复杂点，就是工作线程的实际执行逻辑。简单的说，就是阻塞获取任务，执行。
看到每个 Worker 有自己的锁。
我们还看到 beforeExecute 和 afterExecute 两个钩子方。
看到如果出异常了，直接为抛出去，工作线程就走 processWorkerExit 方法了。
completedAbruptly 这个标记，要是执行的过程中异常了那就是 true 了
这里重点有两个方法 getTask 和 processWorkerExit 。
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())) {
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;
}
}
}这里在 for 循环里面，还是先判断线程池的状态，要 decrementWorkerCount ，是因为外面 addWorker 的时候先 +1 了，return null 后（后面执行 processWorkerExit ），所以这里 -1，继续判断条件，自己看，就是工作线程多了就 -1，然后从任务队列里面限时等待或者阻塞获取任务返回。
再看看 processWorkerExit
private void processWorkerExit(Worker w, boolean completedAbruptly) {
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
completedTaskCount += w.completedTasks;
workers.remove(w);
} finally {
mainLock.unlock();
}
tryTerminate();
int c = ctl.get();
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
addWorker(null, false);
}
} 这个方法看名字叫就是处理工作线程关闭。
首先就是，异常出来的，工作线程数量 -1（因为，如果是返回 null，导致工作线程退出，在 getTask 那里已经 -1 了）。
计算执行的任务数量，移除工作线程，尝试关闭线程池（如果状态是正常的，就没任何影响。）
如果线程池的状态 < STOP (那就是正常状态 或者 刚调用 shutdown 方法)。
如果是异常退出的，直接调用 addWorker 方法（因为工作线程挂掉了，很可能还需要 +1 一个工作线程，不带初始任务，非核心线程）
如果是正常退出的，那么判断一下当前工作线程是否大于最小线程数量，如果不是，一样调用 addWorker 方法。
还有一个方法，就是 reject
final void reject(Runnable command) {
handler.rejectedExecution(command, this);
}直接调用拒绝策略,接口实现，内部有4个实现，默认设置的时候忽略，可以直接实习打印日志之类的，便于排查问题。
public interface RejectedExecutionHandler {
void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}线程池分析到这里就基本差不多了，还有一些关于关闭线程池的方法没看
在上面这些方法中，还看到了一些之前没见过的参数，譬如说 allowCoreThreadTimeOut ，是否允许核心线程超时。
扫一扫
3084
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
