JDK 8 Executor源码详解
1. Executor接口源码
/*
* Executor接口是Java线程池框架的核心接口
* 它提供了一种将任务提交与任务执行机制解耦的标准方式
*/
public interface Executor {
/**
* 执行给定的命令
*
* @param command 要执行的任务，不能为null
* @throws RejectedExecutionException 当任务无法被接受执行时抛出
* @throws NullPointerException 当command为null时抛出
*/
void execute(Runnable command);
}
2. ExecutorService接口源码
public interface ExecutorService extends Executor {
/**
* 关闭线程池，不再接受新任务，但会执行已提交的任务
*/
void shutdown();
/**
* 立即关闭线程池，尝试停止所有正在执行的任务
*
* @return 返回还未开始执行的任务列表
*/
List<Runnable> shutdownNow();
/**
* 判断线程池是否已关闭
*
* @return true表示已关闭
*/
boolean isShutdown();
/**
* 判断线程池是否已终止
*
* @return true表示已终止
*/
boolean isTerminated();
/**
* 阻塞等待线程池终止
*
* @param timeout 等待时间
* @param unit 时间单位
* @return true表示在超时前终止，false表示超时
* @throws InterruptedException 等待过程中被中断
*/
boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
/**
* 提交一个有返回值的任务
*
* @param task 要执行的任务
* @param <T> 返回值类型
* @return Future对象，用于获取结果和管理任务
*/
<T> Future<T> submit(Callable<T> task);
/**
* 提交一个Runnable任务，指定返回值
*
* @param task 要执行的任务
* @param result 任务完成后的返回值
* @param <T> 返回值类型
* @return Future对象
*/
<T> Future<T> submit(Runnable task, T result);
/**
* 提交一个Runnable任务，返回值为null
*
* @param task 要执行的任务
* @return Future对象
*/
Future<?> submit(Runnable task);
/**
* 执行给定的所有任务
*
* @param tasks 任务集合
* @param <T> 任务返回值类型
* @return 所有任务的结果列表
* @throws InterruptedException 被中断时抛出
*/
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException;
/**
* 执行给定的所有任务，带超时时间
*
* @param tasks 任务集合
* @param timeout 超时时间
* @param unit 时间单位
* @param <T> 任务返回值类型
* @return 所有任务的结果列表
* @throws InterruptedException 被中断时抛出
*/
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException;
/**
* 执行给定的任务集合，返回第一个完成的任务结果
*
* @param tasks 任务集合
* @param <T> 任务返回值类型
* @return 第一个完成的任务结果
* @throws InterruptedException 被中断时抛出
* @throws ExecutionException 任务执行异常时抛出
*/
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException;
/**
* 执行给定的任务集合，返回第一个完成的任务结果，带超时
*
* @param tasks 任务集合
* @param timeout 超时时间
* @param unit 时间单位
* @param <T> 任务返回值类型
* @return 第一个完成的任务结果
* @throws InterruptedException 被中断时抛出
* @throws ExecutionException 任务执行异常时抛出
* @throws TimeoutException 超时时抛出
*/
<T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
3. AbstractExecutorService抽象类源码
public abstract class AbstractExecutorService implements ExecutorService {
/**
* 提交Callable任务的实现
*/
@Override
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
// 将Callable任务包装成RunnableFuture
RunnableFuture<T> ftask = newTaskFor(task);
// 执行任务
execute(ftask);
return ftask;
}
/**
* 提交Runnable任务，指定返回值的实现
*/
@Override
public <T> Future<T> submit(Runnable task, T result) {
if (task == null) throw new NullPointerException();
// 将Runnable任务包装成RunnableFuture
RunnableFuture<T> ftask = newTaskFor(task, result);
execute(ftask);
return ftask;
}
/**
* 提交Runnable任务的实现
*/
@Override
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
/**
* 创建新的任务对象
*/
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}
/**
* 创建新的任务对象
*/
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
/**
* 执行所有任务的实现
*/
@Override
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException {
if (tasks == null) throw new NullPointerException();
// 创建结果列表
List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
boolean done = false;
try {
// 为每个任务创建Future并提交执行
for (Callable<T> t : tasks) {
RunnableFuture<T> f = newTaskFor(t);
futures.add(f);
execute(f);
}
// 等待所有任务完成
for (Future<T> f : futures) {
if (!f.isDone()) {
try {
f.get(); // 阻塞等待任务完成
} catch (CancellationException ignore) {
} catch (ExecutionException ignore) {
}
}
}
done = true;
return futures;
} finally {
// 如果过程中出现异常，取消所有未完成的任务
if (!done)
for (Future<T> f : futures)
f.cancel(true);
}
}
/**
* 执行所有任务，带超时的实现
*/
@Override
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException {
if (tasks == null || unit == null)
throw new NullPointerException();
long nanos = unit.toNanos(timeout);
List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
boolean done = false;
try {
// 为每个任务创建Future
for (Callable<T> t : tasks)
futures.add(newTaskFor(t));
long lastTime = System.nanoTime();
// 执行所有任务
Iterator<Future<T>> it = futures.iterator();
while (it.hasNext()) {
execute((Runnable)(it.next()));
long now = System.nanoTime();
nanos -= now - lastTime;
lastTime = now;
if (nanos <= 0)
return futures;
}
// 等待所有任务完成或超时
for (Future<T> f : futures) {
if (!f.isDone()) {
if (nanos <= 0)
return futures;
try {
f.get(nanos, TimeUnit.NANOSECONDS);
} catch (CancellationException ignore) {
} catch (ExecutionException ignore) {
} catch (TimeoutException toe) {
return futures;
}
long now = System.nanoTime();
nanos -= now - lastTime;
lastTime = now;
}
}
done = true;
return futures;
} finally {
if (!done)
for (Future<T> f : futures)
f.cancel(true);
}
}
/**
* 执行任务集合，返回第一个完成的结果
*/
@Override
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;
}
}
/**
* 执行任务集合，返回第一个完成的结果，带超时
*/
@Override
public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
return doInvokeAny(tasks, true, unit.toNanos(timeout));
}
/**
* 实际执行invokeAny的逻辑
*/
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();
List<Future<T>> futures = new ArrayList<Future<T>>(ntasks);
ExecutorCompletionService<T> ecs =
new ExecutorCompletionService<T>(this);
try {
ExecutionException ee = null;
long lastTime = timed ? System.nanoTime() : 0;
Iterator<? extends Callable<T>> it = tasks.iterator();
// 提交第一个任务
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();
long now = System.nanoTime();
nanos -= now - lastTime;
lastTime = now;
} 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(null);
throw ee;
} finally {
// 取消所有未完成的任务
for (Future<T> f : futures)
f.cancel(true);
}
}
}
4. ThreadPoolExecutor核心实现类
public class ThreadPoolExecutor extends AbstractExecutorService {
// 原子整数，用于记录线程池状态和工作线程数
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; // 线程池最大容量
// 线程池状态定义
private static final int RUNNING = -1 << COUNT_BITS; // 运行状态
private static final int SHUTDOWN = 0 << COUNT_BITS; // 关闭状态
private static final int STOP = 1 << COUNT_BITS; // 停止状态
private static final int TIDYING = 2 << COUNT_BITS; // 整理状态
private static final int TERMINATED = 3 << COUNT_BITS; // 终止状态
// 从ctl中提取运行状态
private static int runStateOf(int c) { return c & ~CAPACITY; }
// 从ctl中提取工作线程数
private static int workerCountOf(int c) { return c & CAPACITY; }
// 组合运行状态和工作线程数
private static int ctlOf(int rs, int wc) { return rs | wc; }
// 工作线程集合
private final HashSet<Worker> workers = new HashSet<Worker>();
// 任务队列
private final BlockingQueue<Runnable> workQueue;
// 线程工厂
private volatile ThreadFactory threadFactory;
// 拒绝策略
private volatile RejectedExecutionHandler handler;
// 空闲线程存活时间
private volatile long keepAliveTime;
// 是否允许核心线程超时
private volatile boolean allowCoreThreadTimeOut;
// 核心线程数
private volatile int corePoolSize;
// 最大线程数
private volatile int maximumPoolSize;
/**
* Worker内部类，继承自AbstractQueuedSynchronizer并实现Runnable
* 用于包装工作线程
*/
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
// 实际的工作线程
final Thread thread;
// 第一个任务
Runnable firstTask;
// 完成的任务数
volatile long completedTasks;
/**
* 构造方法
*/
Worker(Runnable firstTask) {
setState(-1); // 禁止中断，直到runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
/**
* 实现Runnable接口
*/
@Override
public void run() {
runWorker(this);
}
// 锁相关方法
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) {
}
}
}
}
/**
* 执行任务的核心方法
*/
@Override
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);
}
/**
* 添加工作线程的核心方法
*/
private boolean addWorker(Runnable firstTask, boolean core) {
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);
// 检查线程数是否超过限制
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 增加工作线程数
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get();
if (runStateOf(c) != rs)
continue retry;
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// 创建Worker对象
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();
// 添加到工作线程集合
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;
}
/**
* 工作线程执行任务的方法
*/
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // 允许中断
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 {
// 执行任务
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;
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 检查是否应该退出
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// 判断是否需要超时控制
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;
}
}
}
/**
* 拒绝任务的处理方法
*/
final void reject(Runnable command) {
handler.rejectedExecution(command, this);
}
/**
* 关闭线程池
*/
@Override
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(SHUTDOWN);
interruptIdleWorkers();
onShutdown(); // 钩子方法
} finally {
mainLock.unlock();
}
tryTerminate();
}
/**
* 立即关闭线程池
*/
@Override
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(STOP);
interruptWorkers();
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
// 其他辅助方法...
}
5. 常用拒绝策略
/**
* 直接抛出异常的拒绝策略
*/
public static class AbortPolicy implements RejectedExecutionHandler {
public AbortPolicy() { }
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
e.toString());
}
}
/**
* 在调用者线程中直接执行任务
*/
public static class CallerRunsPolicy implements RejectedExecutionHandler {
public CallerRunsPolicy() { }
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
r.run();
}
}
}
/**
* 默默丢弃任务
*/
public static class DiscardPolicy implements RejectedExecutionHandler {
public DiscardPolicy() { }
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
// 什么都不做
}
}
/**
* 丢弃最老的任务
*/
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
public DiscardOldestPolicy() { }
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
e.getQueue().poll();
e.execute(r);
}
}
}
6. Executors工具类
public class Executors {
/**
* 创建固定大小的线程池
*/
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
/**
* 创建单线程的线程池
*/
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
/**
* 创建缓存线程池
*/
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
/**
* 创建定时任务线程池
*/
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
}
核心要点总结
1. 线程池状态管理
- 使用一个原子整数ctl同时管理线程池状态和工作线程数
- 3位表示状态，29位表示线程数
2. 任务执行流程
- 判断线程数是否小于核心线程数，是则创建新线程
- 否则尝试加入工作队列
- 队列满则创建新线程直到达到最大线程数
- 达到最大线程数则执行拒绝策略
3. 线程复用机制
- Worker线程不断从队列中获取任务执行
- 通过getTask()方法实现线程的阻塞等待和超时控制
4. 四种拒绝策略
- AbortPolicy：抛出异常
- CallerRunsPolicy：调用者线程执行
- DiscardPolicy：默默丢弃
- DiscardOldestPolicy：丢弃最老任务
这个设计使得线程池能够高效地管理线程资源，避免频繁创建销毁线程带来的性能开销。
扫一扫
972
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
