前面在介绍线程池 ThreadPoolExecutor 时,只关注了执行任务的方法 execute(),ThreadPoolExecutor 中执行任务还有另一个方法–submit(),此方法支持带返回值的线程任务。其底层是基于 FutureTask 来实现的,该类也是 JUC 中提供的并发工具,本篇我们一起走进它的实现细节。
版本说明:本次源码解读基于 JDK1.8,请注意区分。
1. 基本用法
Callable<String> callable = new Callable() {
@Override
public String call() throws Exception {
String result;
// do computing
return result;
}
};
ThreadPoolExecutor executor = new ThreadPoolExecutor(3,
5,
10,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>());
try {
Future<String> futureTask = executor.submit(callable);
try {
System.out.println(futureTask.get());
} catch (ExecutionException e) {
}
}
finally {
executor.shutdown();
}
我们看一下 ThreadPoolExecutor 中 submit() 方法的实现:
// 此方法继承自 ThreadPoolExecutor 的父类 AbstractExecutorService
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}
2. 类关系图
从上图可以看出,FutureTask 实现了 RunnableFuture 接口,而 RunnableFuture 接口分别继承了 Runnable 和 Future 接口。Runnable 接口是我们所熟悉的创建线程的一种方式,因此我们重点看一下 Future 接口:
2.1 Future
// Future 代表一个异步计算的结果。
// 它提供了一些方法:检查任务的完成状态,等待并获取任务结果,以及取消任务。
// 如果我们使用 Future 只是为了使用取消任务的功能,可以将 类型声明为 Future<?>,
// 并且返回 null 作为任务的执行结果即可。
public interface Future<V> {
// 尝试取消任务的执行。
// 如果任务已经完成或者已经被取消,将会尝试失败。
// 如果执行此方法时任务还没有开始执行,这个任务将不会被执行。
// 如果执行此方法时任务正在执行,
// mayInterruptIfRunning 参数来控制是否进行中断。
// 此方法返回后,之后对 isDone() 方法的调用总是返回 true。
// 此方法返回后,如果返回 true,之后对 isCancelled() 方法的调用总是返回 true。
boolean cancel(boolean mayInterruptIfRunning);
// 任务是否已经被成功取消。
// 任务结束前被成功取消,返回真。
boolean isCancelled();
// 任务是否已经完成。
// 任务正常结束,异常结束,或者被成功取消,都算作完成。
boolean isDone();
// 等待计算的完成,并获取执行的结果。
V get() throws InterruptedException, ExecutionException;
// 等待计算的完成,并获取执行的结果。带超时时间。
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
3. FutureTask 实现原理
3.1 属性及构造方法
/**
* The run state of this task, initially NEW. The run state
* transitions to a terminal state only in methods set,
* setException, and cancel. During completion, state may take on
* transient values of COMPLETING (while outcome is being set) or
* INTERRUPTING (only while interrupting the runner to satisfy a
* cancel(true)). Transitions from these intermediate to final
* states use cheaper ordered/lazy writes because values are unique
* and cannot be further modified.
*
* Possible state transitions:
* NEW -> COMPLETING -> NORMAL
* NEW -> COMPLETING -> EXCEPTIONAL
* NEW -> CANCELLED
* NEW -> INTERRUPTING -> INTERRUPTED
*/
private volatile int state;
private static final int NEW = 0;
private static final int COMPLETING = 1;
private static final int NORMAL = 2;
private static final int EXCEPTIONAL = 3;
private static final int CANCELLED = 4;
private static final int INTERRUPTING = 5;
private static final int INTERRUPTED = 6;
/** The underlying callable; nulled out after running */
private Callable<V> callable;
/** The result to return or exception to throw from get() */
// 任务的计算结果,对 outcome 的修改都是基于 state 的 CAS 操作,
// 因此不存在线程安全问题。
private Object outcome; // non-volatile, protected by state reads/writes
/** The thread running the callable; CASed during run() */
private volatile Thread runner;
/** Treiber stack of waiting threads */
private volatile WaitNode waiters;
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
// 初始化 state 为 NEW
this.state = NEW; // ensure visibility of callable
}
public FutureTask(Runnable runnable, V result) {
// 通过工具类 Executors 获得一个适配器
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
Executors.callable()
public static <T> Callable<T> callable(Runnable task, T result) {
if (task == null)
throw new NullPointerException();
return new RunnableAdapter<T>(task, result);
}
static final class RunnableAdapter<T> implements Callable<T> {
final Runnable task;
final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
task.run();
return result;
}
}
3.2 get()
public V get() throws InterruptedException, ExecutionException {
int s = state;
// 如果任务还未完成,等待。
// 任务的完成包含正常结束、异常结束以及取消
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}
awaitDone()
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
for (;;) {
// 如果当前线程被中断,将对应节点移除
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
int s = state;
// 如果任务已经完成,不需要构建节点并压栈
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
else if (s == COMPLETING) // cannot time out yet
Thread.yield();
// 构建新的节点
else if (q == null)
q = new WaitNode();
// waiters 是栈的结构,将新的节点压栈
else if (!queued)
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
// 超时判断
else if (timed) {
// 如果等待的线程已经超时,移除对应节点,返回当前任务状态
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
// 超时,移除节点
removeWaiter(q);
return state;
}
// 带超时时间的挂起
LockSupport.parkNanos(this, nanos);
}
else
LockSupport.park(this);
}
}
report()
private V report(int s) throws ExecutionException {
Object x = outcome;
// 正常结束,返回计算结果
if (s == NORMAL)
return (V)x;
// 被取消,抛出取消异常
if (s >= CANCELLED)
throw new CancellationException();
// 执行过程中出现异常,将异常向上抛
throw new ExecutionException((Throwable)x);
}
3.3 cancel()
public boolean cancel(boolean mayInterruptIfRunning) {
// 只能取消还未执行的任务。
// 如果允许中断,先更新成中间状态,中断线程之后再更新成已中断
if (!(state == NEW &&
UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
return false;
try { // in case call to interrupt throws exception
if (mayInterruptIfRunning) {
try {
Thread t = runner;
if (t != null)
t.interrupt();
} finally { // final state
UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
}
}
} finally {
// 唤醒所有等待获取任务执行结果的线程
finishCompletion();
}
return true;
}
finishCompletion()
private void finishCompletion() {
// assert state > COMPLETING;
for (WaitNode q; (q = waiters) != null;) {
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
for (;;) {
Thread t = q.thread;
if (t != null) {
q.thread = null;
LockSupport.unpark(t);
}
WaitNode next = q.next;
if (next == null)
break;
q.next = null; // unlink to help gc
q = next;
}
break;
}
}
// 供用户扩展的方法
done();
callable = null; // to reduce footprint
}
3.4 run()
public void run() {
// 任务开始执行时,任务的状态必须是 NEW。
// 将任务的 runner 设置成当前线程,设置失败说明任务已被其他线程执行。
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
// 对 state 进行双重检查
if (c != null && state == NEW) {
V result;
boolean ran;
try {
// 任务执行正常结束,得到执行结果
result = c.call();
ran = true;
} catch (Throwable ex) {
// 任务异常结束,将异常作为运行结果
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
// 退出任务执行前,将任务的 runner 置空
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
// 取消任务的方法中,先获取执行任务的线程,再对线程进行非空判断并中断线程。
// 假如非空判断成立后,上面的 runner = null; 才被执行,可能导致泄露。
// 因此这里要对状态重新判断并进行相应处理。
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
set()
// 将 callable 的运行结果作为计算结果返回
protected void set(V v) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
// 唤醒等待计算完成的线程
finishCompletion();
}
}
setException()
// 将异常信息设置成任务的计算结果
protected void setException(Throwable t) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = t;
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
// 唤醒等待任务结束的线程
finishCompletion();
}
}
handlePossibleCancellationInterrupt()
private void handlePossibleCancellationInterrupt(int s) {
// It is possible for our interrupter to stall before getting a
// chance to interrupt us. Let's spin-wait patiently.
// 任务的状态被置为 INTERRUPTING 之后,才去调用线程的中断操作,
// 如果此时线程还未被中断,让出时间片等待中断操作。
if (s == INTERRUPTING)
while (state == INTERRUPTING)
Thread.yield(); // wait out pending interrupt
// assert state == INTERRUPTED;
// We want to clear any interrupt we may have received from
// cancel(true). However, it is permissible to use interrupts
// as an independent mechanism for a task to communicate with
// its caller, and there is no way to clear only the
// cancellation interrupt.
//
// Thread.interrupted();
}
4. 总结
FutureTask 实现了 RunnableFuture 接口,对 Runnable 和 Future 接口进行了实现。run() 方法中实现了任务的执行及计算结果的设置。对 Future 接口的实现,提供了任务执行状态的检查,任务的取消操作,以及任务结果的获取。
在任务执行完毕(包含正常结束,异常结束,被取消)之前,等待获取执行结果的线程一直处于阻塞状态(超时除外),这些线程被构造成 WaitNode 节点对象压入栈中。当任务执行完毕后,会唤醒所有的等待结果的线程并返回执行的结果,如果执行过程中出现异常,则抛出 ExecutionException 异常,如果任务是被取消而结束的,则抛出 CancellationException 异常。
FutureTask 中使用状态机制来管理任务的生命周期。
各个状态的含义如下:
- NEW:初始状态,任务还未被取消或被线程执行。
- COMPLETING:任务执行正常或异常结束,outcome 被设置之前的状态。
- NORMAL:任务执行正常结束,outcome 被设置之后的状态。
- EXCEPTIONAL:任务执行异常结束,outcome 被设置之后的状态。
- CANCELLED:任务被 cancel(false) 方法调用取消后的状态。
- INTERRUPTING:任务被 cancel(true) 方法调用取消时,线程被中断前的中间状态。
- INTERRUPTED:任务被 cancel(true) 方法调用取消后的状态。
状态的转换如下:
- 任务正常结束:NEW -> COMPLETING -> NORMAL
- 任务异常结束:NEW -> COMPLETING -> EXCEPTIONAL
- 任务被 cancel(false) 方法调用取消:NEW -> CANCELLED
- 任务被 cancel(true) 方法调用取消:NEW -> INTERRUPTING -> INTERRUPTED