JDK 8 ExecutorService源码详解（详细注释版）
1. ExecutorService接口源码详解
/*
* ExecutorService接口扩展了Executor接口
* 提供了管理线程池生命周期和任务执行的方法
* 是Java并发编程中线程池操作的核心接口
*/
public interface ExecutorService extends Executor {
/**
* 优雅地关闭线程池
* 不再接受新任务，但是会执行已提交的任务
* 此方法会立即返回，不会等待已提交的任务执行完成
*/
void shutdown();
/**
* 立即关闭线程池
* 尝试停止所有正在执行的任务，不再启动队列中等待的任务
* 并返回那些已提交但尚未开始执行的任务列表
*
* @return 返回还未开始执行的任务列表
* @throws SecurityException 如果安全管理器存在且关闭操作被拒绝
*/
List<Runnable> shutdownNow();
/**
* 判断线程池是否已关闭
* shutdown()或shutdownNow()方法被调用后返回true
*
* @return true表示线程池已关闭，false表示仍在运行
*/
boolean isShutdown();
/**
* 判断线程池是否已终止
* 所有任务都已完成执行后返回true
* 必须先调用shutdown()或shutdownNow()才可能返回true
*
* @return true表示线程池已终止
*/
boolean isTerminated();
/**
* 阻塞等待线程池终止
* 调用shutdown()或shutdownNow()后，阻塞直到所有任务完成执行
* 或者超时发生，或者当前线程被中断
*
* @param timeout 等待的最大时间
* @param unit 时间单位
* @return true表示在超时前终止，false表示超时
* @throws InterruptedException 如果等待时被中断
*/
boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;
/**
* 提交一个有返回值的任务用于执行
* 并返回一个Future对象，用于获取任务结果和管理任务状态
*
* @param task 要执行的任务，不能为null
* @param <T> 任务返回值的类型
* @return 表示任务待处理结果的Future对象
* @throws RejectedExecutionException 如果任务无法被接受执行
* @throws NullPointerException 如果task为null
*/
<T> Future<T> submit(Callable<T> task);
/**
* 提交一个Runnable任务用于执行
* 并返回一个Future对象，Future.get()返回指定的结果
*
* @param task 要执行的任务，不能为null
* @param result 任务完成时返回的结果
* @param <T> 结果的类型
* @return 表示任务待处理结果的Future对象
* @throws RejectedExecutionException 如果任务无法被接受执行
* @throws NullPointerException 如果task为null
*/
<T> Future<T> submit(Runnable task, T result);
/**
* 提交一个Runnable任务用于执行
* 并返回一个Future对象，Future.get()返回null
*
* @param task 要执行的任务，不能为null
* @return 表示任务待处理结果的Future对象
* @throws RejectedExecutionException 如果任务无法被接受执行
* @throws NullPointerException 如果task为null
*/
Future<?> submit(Runnable task);
/**
* 执行给定集合中的所有任务
* 当所有任务完成时，返回保持任务结果的Future列表
* Future列表中每个Future的顺序与给定任务列表中的对应元素顺序相同
*
* @param tasks 任务集合
* @param <T> 任务返回值的类型
* @return 表示任务结果的Future列表（按给定任务列表的顺序）
* @throws InterruptedException 如果等待时被中断，在这种情况下取消尚未完成的任务
* @throws NullPointerException 如果tasks或其任何元素为null
*/
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException;
/**
* 执行给定集合中的所有任务，并设置超时时间
* 当所有任务完成或超时发生时，返回保持任务结果的Future列表
* Future列表中每个Future的顺序与给定任务列表中的对应元素顺序相同
* 如果超时发生，未完成的任务会被取消
*
* @param tasks 任务集合
* @param timeout 等待的最长时间
* @param unit 时间单位
* @param <T> 任务返回值的类型
* @return 表示任务结果的Future列表（按给定任务列表的顺序）
* @throws InterruptedException 如果等待时被中断，在这种情况下取消尚未完成的任务
* @throws NullPointerException 如果tasks、任何任务或unit为null
* @throws TimeoutException 如果在所有任务完成前超时
*/
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException;
/**
* 执行给定集合中的任务，返回其中一个成功完成（未抛出异常）的任务结果
* 一旦某个任务成功完成，其他未完成的任务会被取消
*
* @param tasks 任务集合
* @param <T> 任务返回值的类型
* @return 成功完成的任务的结果
* @throws InterruptedException 如果等待时被中断
* @throws NullPointerException 如果tasks或其任何元素为null
* @throws IllegalArgumentException 如果tasks为空
* @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 NullPointerException 如果tasks、任何任务或unit为null
* @throws TimeoutException 如果在所有任务成功完成前超时
* @throws ExecutionException 如果没有任务成功完成，或者计算过程中抛出异常
*/
<T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
2. AbstractExecutorService抽象类源码详解
/*
* AbstractExecutorService是ExecutorService接口的抽象实现
* 提供了submit、invokeAny和invokeAll等方法的默认实现
* 通过RunnableFuture包装任务，简化了ExecutorService的实现
*/
public abstract class AbstractExecutorService implements ExecutorService {
/**
* 将Callable任务包装成RunnableFuture对象
* 这是submit方法的核心实现
*
* @param callable 要包装的Callable任务
* @param <T> 任务返回值类型
* @return 包装后的RunnableFuture对象
*/
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}
/**
* 将Runnable任务和结果包装成RunnableFuture对象
*
* @param runnable 要包装的Runnable任务
* @param value 任务完成时返回的值
* @param <T> 结果类型
* @return 包装后的RunnableFuture对象
*/
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
/**
* 提交Callable任务的核心实现
* 将任务包装成FutureTask并执行
*
* @param task 要提交的Callable任务
* @param <T> 任务返回值类型
* @return 表示任务结果的Future对象
* @throws NullPointerException 如果task为null
*/
@Override
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
// 将Callable任务包装成RunnableFuture
RunnableFuture<T> ftask = newTaskFor(task);
// 调用execute方法执行任务
execute(ftask);
return ftask;
}
/**
* 提交Runnable任务并指定返回结果的核心实现
*
* @param task 要提交的Runnable任务
* @param result 任务完成时返回的结果
* @param <T> 结果类型
* @return 表示任务结果的Future对象
* @throws NullPointerException 如果task为null
*/
@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任务的核心实现
*
* @param task 要提交的Runnable任务
* @return 表示任务结果的Future对象（结果为null）
* @throws NullPointerException 如果task为null
*/
@Override
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
// 将Runnable任务包装成RunnableFuture
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
/**
* 执行所有任务的核心实现
*
* @param tasks 任务集合
* @param <T> 任务返回值类型
* @return 所有任务的结果列表
* @throws InterruptedException 如果执行过程中被中断
* @throws NullPointerException 如果tasks为null
*/
@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);
}
}
/**
* 执行所有任务，带超时控制的核心实现
*
* @param tasks 任务集合
* @param timeout 超时时间
* @param unit 时间单位
* @param <T> 任务返回值类型
* @return 所有任务的结果列表
* @throws InterruptedException 如果执行过程中被中断
* @throws TimeoutException 如果超时
* @throws NullPointerException 如果tasks或unit为null
*/
@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);
}
}
/**
* 执行任务集合，返回第一个完成的结果
*
* @param tasks 任务集合
* @param <T> 任务返回值类型
* @return 第一个完成的任务结果
* @throws InterruptedException 如果执行过程中被中断
* @throws ExecutionException 如果任务执行过程中抛出异常
* @throws NullPointerException 如果tasks为null
*/
@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;
}
}
/**
* 执行任务集合，返回第一个完成的结果，带超时控制
*
* @param tasks 任务集合
* @param timeout 超时时间
* @param unit 时间单位
* @param <T> 任务返回值类型
* @return 第一个完成的任务结果
* @throws InterruptedException 如果执行过程中被中断
* @throws ExecutionException 如果任务执行过程中抛出异常
* @throws TimeoutException 如果超时
* @throws NullPointerException 如果tasks或unit为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逻辑的私有方法
* 使用ExecutorCompletionService来管理任务完成情况
*
* @param tasks 任务集合
* @param timed 是否启用超时控制
* @param nanos 超时时间（纳秒）
* @param <T> 任务返回值类型
* @return 第一个完成的任务结果
* @throws InterruptedException 如果执行过程中被中断
* @throws ExecutionException 如果任务执行过程中抛出异常
* @throws TimeoutException 如果超时
*/
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);
}
}
}
3. ExecutorCompletionService源码详解
/*
* ExecutorCompletionService是CompletionService接口的实现
* 将Executor和BlockingQueue结合，用于管理异步任务的完成
* 提供了更方便的任务完成通知机制
*/
public class ExecutorCompletionService<V> implements CompletionService<V> {
private final Executor executor;
private final AbstractExecutorService aes;
private final BlockingQueue<Future<V>> completionQueue;
/**
* 私有的FutureTask实现，用于将结果放入完成队列
*/
private class QueueingFuture extends FutureTask<Void> {
QueueingFuture(RunnableFuture<V> task) {
super(task, null);
this.task = task;
}
private final Future<V> task;
/**
* 任务完成后将Future放入完成队列
*/
@Override
protected void done() {
completionQueue.add(task);
}
}
/**
* 构造方法，使用默认的LinkedBlockingQueue
*
* @param executor 执行任务的Executor
* @throws NullPointerException 如果executor为null
*/
public ExecutorCompletionService(Executor executor) {
if (executor == null)
throw new NullPointerException();
this.executor = executor;
this.aes = (executor instanceof AbstractExecutorService) ?
(AbstractExecutorService) executor : null;
this.completionQueue = new LinkedBlockingQueue<Future<V>>();
}
/**
* 构造方法，使用指定的BlockingQueue
*
* @param executor 执行任务的Executor
* @param completionQueue 用于保存完成结果的队列
* @throws NullPointerException 如果executor或completionQueue为null
*/
public ExecutorCompletionService(Executor executor,
BlockingQueue<Future<V>> completionQueue) {
if (executor == null || completionQueue == null)
throw new NullPointerException();
this.executor = executor;
this.aes = (executor instanceof AbstractExecutorService) ?
(AbstractExecutorService) executor : null;
this.completionQueue = completionQueue;
}
/**
* 提交Callable任务
*
* @param task 要执行的任务
* @return 表示任务的Future对象
* @throws NullPointerException 如果task为null
*/
@Override
public Future<V> submit(Callable<V> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<V> f = aes == null ?
new FutureTask<V>(task) :
aes.newTaskFor(task);
executor.execute(new QueueingFuture(f));
return f;
}
/**
* 提交Runnable任务
*
* @param task 要执行的任务
* @param result 任务完成时返回的结果
* @return 表示任务的Future对象
* @throws NullPointerException 如果task为null
*/
@Override
public Future<V> submit(Runnable task, V result) {
if (task == null) throw new NullPointerException();
RunnableFuture<V> f = aes == null ?
new FutureTask<V>(task, result) :
aes.newTaskFor(task, result);
executor.execute(new QueueingFuture(f));
return f;
}
/**
* 获取下一个完成的任务结果，阻塞等待
*
* @return 下一个完成的Future对象
* @throws InterruptedException 如果等待时被中断
*/
@Override
public Future<V> take() throws InterruptedException {
return completionQueue.take();
}
/**
* 获取下一个完成的任务结果，非阻塞
*
* @return 下一个完成的Future对象，如果没有则返回null
*/
@Override
public Future<V> poll() {
return completionQueue.poll();
}
/**
* 获取下一个完成的任务结果，带超时控制
*
* @param timeout 等待时间
* @param unit 时间单位
* @return 下一个完成的Future对象，超时返回null
* @throws InterruptedException 如果等待时被中断
*/
@Override
public Future<V> poll(long timeout, TimeUnit unit)
throws InterruptedException {
return completionQueue.poll(timeout, unit);
}
}
4. 关键设计要点总结
4.1 Future模式的应用
// Future接口提供了异步计算的结果管理
public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning); // 取消任务
boolean isCancelled(); // 判断是否被取消
boolean isDone(); // 判断是否完成
V get() throws InterruptedException, ExecutionException; // 获取结果
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; // 带超时获取结果
}
4.2 线程池生命周期管理
- RUNNING: 接受新任务并处理队列中的任务
- SHUTDOWN: 不接受新任务，但处理队列中的任务
- STOP: 不接受新任务，不处理队列中的任务，并中断正在执行的任务
- TIDYING: 所有任务都已终止，执行terminated()钩子方法
- TERMINATED: terminated()方法已完成
4.3 任务提交与执行分离
通过将任务包装成FutureTask，实现了任务提交与执行的解耦，使得调用者可以通过Future对象管理任务状态和获取结果。
4.4 异常处理机制
- 使用ExecutionException包装任务执行中的异常
- 通过Future接口提供统一的异常获取方式
- invokeAll和invokeAny方法中的异常处理策略不同
这些设计使得ExecutorService成为一个强大而灵活的并发编程工具，为Java应用提供了高效的线程管理和任务执行能力。
扫一扫
363
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
