一:简介
1.上文介绍了Future的使用,Future一般搭配Callable来使用,一般我们使用Thread或者ExecutorService来执行,并返回执行结果Future;
2.在JDK中,FutureTask实现了Future,并且封装了Runnable和Callable两种形式的任务;
3.该源码的环境是一个FutureTask被Thread A执行,一个Thread List 等待调用它的执行结果,所以它的方法分为2部分,一部分是线程A执行的run(),另一部分是供Thread List执行的get()、cancel等,其中get()是通过循环等待、yield等阻塞等待线程的执行结果的;
4.下面将从成员变量、构造方法、get()、get(long,TimeUnit)、run()、cancel(boolean)方法来剖析它的运行机制;
二:成员变量和构造方法
1.FutureTask的成员变量包括:state执行状态、callable、outcome
/**volatile变量,用来表示当前Futuretask的状态,初始状态为null,状态切换到终结状态,仅仅能通过
set、setException和cancel方法,在完成的期间,状态可能是completing或interrupting,这些
转换使用延迟写,因为这些值是独特的不能被更远的修改,下面是可能的状态转换:*/
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 ,运行以后变为null*/
private Callable<V> callable;
//运行结果或者异常,non-volatile,但是它是受state的值来保护的
/** The result to return or exception to throw from get() */
private Object outcome; // non-volatile, protected by state reads/writes
//运行该FutureTask的线程
/** The thread running the callable; CASed during run() */
private volatile Thread runner;
//等待该FutureTask结果的线程s
/** Treiber stack of waiting threads */
private volatile WaitNode waiters;
2.FutureTask提供了2种构造方法来支持,其中支持Runnable是使用RunnableAdapter封装了一层:
//支持Callable
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
//支持Runnable
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
//使用RunnableAdapter来封装Runnable,来代替Callable
public static <T> Callable<T> callable(Runnable task, T result) {
if (task == null)
throw new NullPointerException();
return new RunnableAdapter<T>(task, result);
}
//继承了Callable,用来执行Runnable,并返回结果
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.内部类WaitNode,使用链表 的方式,来记录等待Future结果的线程:
static final class WaitNode {
volatile Thread thread;
volatile WaitNode next;
WaitNode() { thread = Thread.currentThread(); }
}
二:方法剖析
在这里,一般认为线程A中通过Thread或者线程池,执行了FutureTask.run(),然后一个List来调用FutureTask.get(),来获取执行结果,当然List中可能包含线程A,也可能不包含;
在FutureTask中最重要的几个方法为:执行函数run、获取结果get,取消cancel,下面将会重点介绍这三个方法;
1.run'方法,线程A执行
a)run方法分三部分:Callable.call()、set()、setException()和等待Interrupt完成的handlePossibleCancellationInterrupt()组成,set()、setException()中又包含了对waiters队列操作的finishCompletion()方法:
//这是线程A的执行
public void run() {
//若当前Task状态不为NEW,或者CAS设置runner失败,则退出
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
//当可执行任务callable不为null,且状态为NEW,继续执行
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
//异常情况下,设置result
result = null;
ran = false;
setException(ex);
}
//正常返回的情况下,设置result
if (ran)
set(result);
}
} finally {
// runner必须设置为非null直到状态被设置,防止并发执行
runner = null;
// state必须重写读取,防止泄露的中断
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
b)set()、setException()方法主要分为2部分,一部分是通过UnSafe进行CAS赋值,另一部分是操作waiters队列:
protected void set(V v) {
//CAS设置Completing之后,再赋值为Normal结束
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}
protected void setException(Throwable t) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = t;
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
finishCompletion();
}
}
c)finishCompletion是设置waiter队列为null,并设置每个node的thread为null:
private void finishCompletion() {
// assert state > COMPLETING;
//循环,直至waiters为null
for (WaitNode q; (q = waiters) != null;) {
//CAS设置waiters为null
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
for (;;) {
Thread t = q.thread;
//如果当前Node不为空,设置thread为null,并解除阻塞
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
}
d)特别说下done()方法,是为了子类可以自定义完成以后的逻辑,而定义的方法:
/**当task的状态转换成Done时,该Protected方法被调用,它的默认实现没有做任何事情。子类可以重载这个方法去调用完成后的Callback或记录
*/
protected void done() { }
e)handlePossibleCancellationInterrupt是为了防止一种特殊场景,等待Interrupting变为Interrupted:
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.
if (s == INTERRUPTING)
while (state == INTERRUPTING)
Thread.yield(); // wait out pending interrupt
}
2.get方法,List线程执行
a)get方法主要由report和awaitDone方法组成,先介绍get和report方法,report方法是用来根据task状态返回结果或者抛出异常的方法:
public V get() throws InterruptedException, ExecutionException {
int s = state;
//若当前task的状态为Completing,表示正在执行中,则等待task执行完成
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}
private V report(int s) throws ExecutionException {
Object x = outcome;
//正常返回,则返回result
if (s == NORMAL)
return (V)x;
//若被cancel、Interrupt相关,则跑步cancel异常
if (s >= CANCELLED)
throw new CancellationException();
//若为Exceptional,则抛出execution异常
throw new ExecutionException((Throwable)x);
}
b)get(long timeout, @NotNull TimeUnit unit)方法,这个方法是为了防止线程内部发生了异常、死循环等无限等待的情况,而引入的超时获取方法:
public V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
//如果时间单元为null,则抛出异常
if (unit == null)
throw new NullPointerException();
int s = state;
//当为New、Completing时,继续去等待获取结果,若超时,仍未获取结果,则抛出异常
if (s <= COMPLETING &&
(s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
throw new TimeoutException();
return report(s);
}
c)awaitDone方法,该方法是用来等待,并获取结果,采用的是无限循环的方法:
/**等待完成、中断,或者超时*/
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
//若需要超时机制,timed为true,deadline为当前时间加上超时时间
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
for (;;) {
//若调用future.get()方法的线程被中断了,则从waiter列表中移除该线程,并抛出异常
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
int s = state;
//若为normal、exceptional、cancelled、interrupting、interrupted,则返回,交由report处理
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
//若为completing,则放弃时间片,等待下次时间片
else if (s == COMPLETING) // cannot time out yet
Thread.yield();
else if (q == null)
//若需要等待,总会有一次进来,设置当前线程的waiterNode
q = new WaitNode();
//有且仅有一次设置成功,将当前线程的waiterNode加到waiters队列中
else if (!queued)
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
//用于超时机制,若超时,则一处waiterNode,并返回
else if (timed) {
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
//若未超时,则阻塞当前线程
LockSupport.parkNanos(this, nanos);
}
else
//阻塞当前线程
LockSupport.park(this);
}
}
d)removewaiter方法,此方法写的相当精妙,我自认熟写链表,感觉还是差不少距离:
private void removeWaiter(WaitNode node) {
if (node != null) {
//将需要删除node的thread设置为null,做标志使用
node.thread = null;
retry:
for (;;) { // restart on removeWaiter race
//循环waiters队列,找到被删除的node
for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
s = q.next;
//q.thread不为null,表示不是当前node
if (q.thread != null)
pred = q;
else if (pred != null) {
pred.next = s;
//如果上一个thread为null,防止并发情况下的操作
if (pred.thread == null) // check for race
continue retry;
}
//thread为null,表示要删除当前node,pred为null,表示node为首节点
else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,
q, s))
continue retry;
}
break;
}
}
}
3.cancel方法,List线程执行
a)cancel方法主要分为设置状态、Interrupt执行线程、finishCompletion三部分,参数MayInterruptIfRunning表示运行时是否可以Interrupt:
public boolean cancel(boolean mayInterruptIfRunning) {
//如果状态为New,且当前状态期望值为New,设置为Interrupting或Cancelled成功,则不返回false
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;
}