FutureTask源码分析
写在前面
本文主要介绍FutureTask（基于java1.8.0_202），FutureTask是Future接口的一个实现类。FutureTask是线程安全的，Future的方法，例如get()、cancel等是可以在多个线程中调用的，FutureTask在实现时考虑了这些问题。
我们平时在使用线程池的submit方法时，例如AbstractExecutorService#submit(Callable) 或者 AbstractExecutorService#submit(Runnable)，内部也是将Callable和Runnable转换成了FutureTask，我们调用的Future#get等方法实际上用到的都是FutureTask#get方法。
此外，FutureTask的实现有两个有意思的点，包括无锁栈Treiber Stack和直接用Unsafe来操作一些字段。在下面的源码分析中，我们会依次进行详细介绍。
Future接口
首先回顾下Future接口中定义的方法和含义。
public interface Future<V> {
/** 尝试取消任务的执行。如果任务已经执行完成了、已经执行结束了、或者因为其他原因不能被取消，则返回false。如果任务还没有被执行，则会返回true并且异步任务不会被执行。如果任务已经开始执行了但是还没有执行完成，若mayInterruptIfRunning为true，则会立即中断执行任务的线程并返回true，若mayInterruptIfRunning为false，则会返回true且不会中断任务执行线程。 当cancel方法返回后，后续调用isDone()总是返回true；当cancel方法返回true后，后续调用isCancelled总是返回true。 */
boolean cancel(boolean mayInterruptIfRunning);
/** 任务正常结束前被取消则返回true，否则返回false */
boolean isCancelled();
/** 如果任务完成则返回true，任务完成包括正常结束、执行过程中抛出异常、被取消这3种情况。 */
boolean isDone();
/** 获取任务执行结果，如果任务还没完成则会阻塞等待直到任务执行完成。如果任务被取消则会抛出CancellationException异常，如果任务执行过程发生异常则会抛出ExecutionException异常，如果阻塞等待过程中被中断则会抛出InterruptedException异常。 */
V get() throws InterruptedException, ExecutionException;
/** 带超时时间的get()，如果阻塞等待过程中超时则会抛出TimeoutException异常，其余行为和get一致*/
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}
FutureTask的属性
FutureTask的各个方法是围绕state设计的，state的数值大小是经过设计的，类似ThreadPoolExecutor中表示线程池状态的state。COMPLETING状态是任务是否执行完成的临界状态。当state<=COMPLETING时，说明任务还没运行完；state>COMPLETING的状态都表示任务已经执行完成(任务正常执行完成，任务执行异常或者任务被取消)。
可能的状态转换如下
- NEW -> COMPLETING -> NORMAL
- NEW -> COMPLETING -> EXCEPTIONAL
- NEW -> CANCELLED
- NEW -> INTERRUPTING -> INTERRUPTED
/** 任务的运行状态。使用volatile修饰，所有线程都能看到state的最新值 */
private volatile int state;
/**初始状态。表示是个新的任务或者还没被执行完的任务。 */
private static final int NEW = 0;
/** 任务已经执行完成或者执行任务的时候发生异常，但是任务执行结果或者异常原因还没有保存到outcome字段，状态会从NEW变更到COMPLETING。这个状态会时间会比较短，属于中间状态。 */
private static final int COMPLETING = 1;
/** 任务已经执行完成并且任务执行结果已经保存到outcome字段，状态会从COMPLETING转换到NORMAL。这是一个最终态。可以参考set方法 */
private static final int NORMAL = 2;
/** 任务执行发生异常并且异常原因已经保存到outcome字段中后，状态会从COMPLETING转换到EXCEPTIONAL。这是一个最终态。 可以参考setException方法*/
private static final int EXCEPTIONAL = 3;
/** 任务还没开始执行或者已经开始执行但是还没有执行完成的时候，用户调用了cancel(false)方法取消任务且不中断任务执行线程，这个时候状态会从NEW转化为CANCELLED状态。这是一个最终态。 */
private static final int CANCELLED = 4;
/** 任务还没开始执行或者已经执行但是还没有执行完成的时候，用户调用了cancel(true)方法取消任务并且要中断任务执行线程但是还没有中断任务执行线程之前，状态会从NEW转化为INTERRUPTING。这是一个中间状态。 */
private static final int INTERRUPTING = 5;
/** 调用interrupt()中断任务执行线程之后状态会从INTERRUPTING转换到INTERRUPTED。这是一个最终态。 */
private static final int INTERRUPTED = 6;
/** The underlying callable; nulled out after running */
private Callable<V> callable;
/** 任务正常执行完则保存任务执行结果，如果发生异常则用来保存异常原因*/
private Object outcome; // non-volatile, protected by state reads/writes
/** The thread running the callable; CASed during run() */
private volatile Thread runner;
/** 指向Treiber stack的栈顶元素 */
private volatile WaitNode waiters;
// Unsafe mechanics
private static final sun.misc.Unsafe UNSAFE;
private static final long stateOffset;
private static final long runnerOffset;
private static final long waitersOffset;
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class<?> k = FutureTask.class;
stateOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("state"));
runnerOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("runner"));
waitersOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("waiters"));
} catch (Exception e) {
throw new Error(e);
}
}
FutureTask中直接使用Unsafe来操作state、runner和waiters字段，而没有使用AtomicInteger、AtomicReference，主要是出于性能考虑，通过直接使用Unsafe自身的方法来绕过使用AtomicXFieldUpdaters的开销。
FutureTask内部类WaitNode
TreiberStack的节点，保存等待中的线程。
static final class WaitNode {
volatile Thread thread;
volatile WaitNode next;
WaitNode() { thread = Thread.currentThread(); }
}
FutureTask主要方法分析
构造方法
FutureTask有两个构造方法，构造方法中会把state置为NEW。
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
public FutureTask(Runnable runnable, V result) {
// 将runnable转成callable
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
run方法
FutureTask实现了Runnable接口，本身也是一个任务，可以在线程中执行。
// state不是NEW直接返回；如果状态是NEW，则将当前线程设置成runner，如果失败（多个线程同时执行一个FutureTask的run方法）则直接返回
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
// 任务执行时抛出异常，则调用setException方法
setException(ex);
}
if (ran)
// 任务正常执行结束，则调用set方法
set(result);
}
} finally {
// 为了防止并发的调用run，需要将state设置完才能将runner置为null
runner = null;
// state must be re-read after nulling runner to prevent leaked interrupts
int s = state;
// 如果任务被中断，需要处理中断
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
setException方法
protected void setException(Throwable t) {
// 将state从NEW置为COMPLETING，如果state已经变了（例如被任务被取消了），则会设置失败
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
// 将异常设置到outcome字段
outcome = t;
// 将状态设置成EXCEPTIONAL
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
finishCompletion();
}
}
set方法
protected void set(V v) {
// 将state从NEW置为COMPLETING，如果state已经变了（例如被任务被取消了），则会设置失败
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
// 将结果保存在outcome字段
outcome = v;
// 将状态设置成NORMAL
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}
finishCompletion方法
finishCompletion方法主要做了3件事
- 移除并通知所有等待的线程
- 执行done方法
- 将callable置为null
private void finishCompletion() {
// assert state > COMPLETING;
for (WaitNode q; (q = waiters) != null;) {
// 将waiters置为null，也就是将栈顶元素置为null。如果执行失败会重试，直到waiters是null，即没有等待的Node了
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
for (;;) {
Thread t = q.thread;
if (t != null) {
// 将q对应的thread置为null
q.thread = null;
// 在awaitDone方法阻塞的线程会返回
LockSupport.unpark(t);
}
WaitNode next = q.next;
if (next == null)
// 当前节点没有后继节点的话，会跳出 for (;;) 循环，执行done
break;
q.next = null; // unlink to help gc
// q指向当前节点的下一个节点，继续循环
q = next;
}
// 跳出for (WaitNode q; (q = waiters) != null;)循环
break;
}
}
done();
callable = null; // to reduce footprint
}
get方法
get方法是我们在开发中用的比较多的一个方法，这个方法的实现相对复杂些，我们这里着重分析下。
public V get() throws InterruptedException, ExecutionException {
int s = state;
// 如果任务没运行完，则调用awaitDone方法
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}
// 在调用get方法时，timed是false，nanos是0L，我们这里以timed是false且nanos是0L进行分析
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
// 死循环
for (;;) {
// 如果线程被中断了，则移除waiter，并抛出InterruptedException
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
int s = state;
// 任务已经结束了（正常完成、抛出异常、被取消）则返回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)
// 第一次进入循环可能会走到这里，此时创建一个WaitNode保存当前线程，然后继续循环。
q = new WaitNode();
else if (!queued)
// 走到这里，说明q不是null了，此时要把当前线程加入到Treiber stack中。加入stack后，下一次循环大概率会走到下面的LockSupport.park(this)中
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
// 当前线程加入到栈之后，使用park进行阻塞。我们上面在分析setException和set方法时知道，最终这两个方法会调用finishCompletion方法，finishCompletion会调用LockSupport.unpark方法，让等待的线程从这里返回
LockSupport.park(this);
}
}
这里再看下这句，这句也就是FutureTask是怎么往Stack中添加元素的。
q.next = waiters将q.next指向waiters，执行的返回值是waiters，然后将waiters替换成q。
假设初始时waiters是null，则第一个调用get方法的线程，假设线程名是T1，则waiters指向了T1，T1的next是null。
假设此时又有一个线程T2调用了get方法，则首先让T2的next指向T1，然后让waiters指向T2。
假设又有一个线程T3调用了get方法，则首先让T3的next指向T2，然后让waiters指向T2。
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
我们Debug下上述的过程，示例代码如下。
public static void main(String[] args) throws InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(2);
// 模拟任务运行
Future<Long> future = executorService.submit(() -> {
try {
TimeUnit.SECONDS.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 1L;
});
// 在T1线程里调用future.get
new Thread(() -> {
try {
future.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}, "T1").start();
// 确保T1先于T2启动
TimeUnit.SECONDS.sleep(1);
// 在T2线程里调用future.get
new Thread(() -> {
try {
future.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}, "T2").start();
// 确保T2先于T3启动
TimeUnit.SECONDS.sleep(1);
// 在T3线程里调用future.get
new Thread(() -> {
try {
future.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}, "T3").start();
TimeUnit.SECONDS.sleep(1);
System.out.println("Here");
}
T1执行
T2执行
T3执行
report方法
在get方法最后，会调用report方法返回执行结果或是抛出异常。
private V report(int s) throws ExecutionException {
Object x = outcome;
// 任务正常执行结束，直接返回
if (s == NORMAL)
return (V)x;
// 任务被取消，则抛出CancellationException
if (s >= CANCELLED)
throw new CancellationException();
// 任务抛出异常，则抛出ExecutionException
throw new ExecutionException((Throwable)x);
}
最后
JUC在执行任务时在很多地方都使用了FutureTask，了解FutureTask的源码能够让我们更好的使用Future的方法~
537
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
