本文主要介绍FutureTask中的核心方法，如果有错误，欢迎大家指出！
首先我们看一下在java中FutureTask的组织关系
我们看一下FutureTask中关键的成员变量以及其构造方法
//表示当前task状态
private volatile int state;
//当前任务尚未执行
private static final int NEW = 0;
//当前任务正在结束，稍微完全结束，一种临界状态
private static final int COMPLETING = 1;
//当前任务正常结束
private static final int NORMAL = 2;
//当前任务执行过程中发生了异常。 内部封装的 callable.run() 向上抛出异常了
private static final int EXCEPTIONAL = 3;
//当前任务被取消
private static final int CANCELLED = 4;
//当前任务中断中..
private static final int INTERRUPTING = 5;
//当前任务已中断
private static final int INTERRUPTED = 6;
//submit(runnable/callable) runnable 使用 装饰者模式 伪装成 Callable了。
private Callable<V> callable;
//正常情况下：任务正常执行结束，outcome保存执行结果。 callable 返回值。
//非正常情况：callable向上抛出异常，outcome保存异常
private Object outcome;
//当前任务被线程执行期间，保存当前执行任务的线程对象引用。
private volatile Thread runner;
/** Treiber stack of waiting threads */
//因为会有很多线程去get当前任务的结果，所以 这里使用了一种数据结构 stack
private volatile WaitNode waiters;
/**
* 如果传进来的是一个Callable接口，callable就是程序员自己实现的业务类
*/
public FutureTask(Callable<V> callable) {
//如果传入的callable为null，抛出空指针异常
if (callable == null)
throw new NullPointerException();
this.callable = callable;
//设置当前任务状态为 NEW
this.state = NEW; // ensure visibility of callable
}
/**
* 如果传入的是一个Runnable接口
* 使用装饰者模式将runnable转换为了 callable接口，
* 外部线程通过get获取当前任务执行结果时，结果可能为 null 也可能为 传进来的值。
*/
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
/**
* 将一个Runnable接口封装为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;
}
｝
FutureTask中的Run方法
public void run() {
//条件一：state != NEW 条件成立，说明当前task已经被执行过了 或者 被cancel 了，总之非NEW状态的任务，线程就不处理了。
//条件二：!UNSAFE.compareAndSwapObject(this, runnerOffset,null, Thread.currentThread())
// 条件成立：cas失败，当前任务被其它线程抢占了...
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
//执行到这里，当前task一定是 NEW 状态
// 而且 当前线程也抢占TASK成功（runner中存放着当前的线程对象）！
try {
//自己封装的callable或者runnable
Callable<V> c = callable;
//条件一：c != null 防止空指针异常
//条件二：state == NEW 防止外部线程 cancel掉当前任务。
if (c != null && state == NEW) {
V result;
//true 表示callable.run 代码块执行成功 未抛出异常
//false 表示callable.run 代码块执行失败 抛出异常
boolean ran;
try {
//调用程序员自己实现的callable 或者 装饰后的runnable
result = c.call();
//c.call未抛出任何异常，ran会设置为true 代码块执行成功
ran = true;
} catch (Throwable ex) {
//说明程序员自己写的逻辑块有bug了。
result = null;
ran = false;
//说明是从异常出来的，将异常设置在结果中
setException(ex);
}
//说明当前c.call正常执行结束了。
//set就是设置结果到outcome
if (ran)
set(result);
}
} finally {
//在执行过程中runner的值一定不为null
//防止并发调用run（）
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
//看当前状态是否是中断状态，如果是处理中断操作
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
//正常结束
protected void set(V v) {
//使用CAS方式设置当前任务状态为 完成中..
//有没有可能失败呢？ 外部线程等不及了，直接在set执行CAS之前 将 task取消了。 很小概率事件。
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
//将结果赋值给 outcome之后，马上会将当前任务状态修改为 NORMAL 正常结束状态。
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}
//异常结束
protected void setException(Throwable t) {
//使用CAS方式设置当前任务状态为 完成中..
//有没有可能失败呢？ 外部线程等不及了，直接在set执行CAS之前 将 task取消了。 很小概率事件。
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
//将异常封装在结果中返回
outcome = t;
//将当前任务的状态 修改为 EXCEPTIONAL
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
//说明现在已经结束了
finishCompletion();
}
}
/**
* 结束以后要负责唤醒等待栈中真在等待获取结果的线程
*/
private void finishCompletion() {
// assert state > COMPLETING;
//q指向waiters 链表的头结点。
for (WaitNode q; (q = waiters) != null;) {
//使用cas设置 waiters 为 null 是因为怕
//外部线程使用 cancel 取消当前任务 也会触发finishCompletion方法。 小概率事件。
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
for (;;) {
//获取当前node节点封装的 thread
Thread t = q.thread;
if (t != null) {
q.thread = null;
//唤醒当前节点对应的线程
LockSupport.unpark(t);
}
//next 当前节点的下一个节点
WaitNode next = q.next;
if (next == null)
break;
q.next = null; // unlink to help gc
q = next;
}
break;
}
}
done();
callable = null; // to reduce footprint
}
/**
* 处理有可能的取消中断
*/
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
// 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();
}
FutureTask中Get方法
public V get() throws InterruptedException, ExecutionException {
int s = state;
//条件成立：未执行、正在执行。 调用get的外部线程会被阻塞在get方法上。
//核心方法
// private static final int NEW = 0;
// private static final int COMPLETING = 1;
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}
//同样的作用设置了超时时间
public V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
if (unit == null)
throw new NullPointerException();
int s = state;
//如果当前状态小于等于COMPLETING并且调用了awaitDone方法以后还是小于等于COMPLETING，说明当前是超时以后返回的
if (s <= COMPLETING &&
(s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
throw new TimeoutException();
return report(s);
}
/**
* 等待任务完成然后获取结果
*/
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
//timed等于false不带超时
//timed等于true带超时
final long deadline = timed ? System.nanoTime() + nanos : 0L;
//引用当前线程 封装成 WaitNode 对象
WaitNode q = null;
//表示当前线程waitNode对象 有没有压栈
boolean queued = false;
for (;;) {
//条件成立：说明当前线程唤醒 是被其它线程使用中断这种方式喊醒的。interrupted()
//返回true 后会将 Thread的中断标记重置回false.
if (Thread.interrupted()) {
//当前线程node出队
removeWaiter(q);
//get方法会得动中断异常
throw new InterruptedException();
}
//假设是被其他线程正常唤醒或者超时自动返回
int s = state;
//条件成立，说明当前任务已经有结果了
if (s > COMPLETING) {
//条件成立，说明已经为当前线程创建过node了
if (q != null)
q.thread = null;
//返回当前状态
return s;
}
//条件成立：说明当前任务接近完成状态...这里让当前线程再释放cpu ，进行下一次抢占cpu。
else if (s == COMPLETING) // cannot time out yet
Thread.yield();
//创建WaitNode对象
else if (q == null)
q = new WaitNode();
//条件成立：第二次自旋，当前线程已经创建 WaitNode对象了，但是node对象还未入栈
else if (!queued)
//将当前节点入栈
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
//第三次自旋，会到这里。
//如果是带有超时时间的，在超时时间里面变为 WAITING状态，相当于休眠了.
//除非有其它线程将你唤醒 或者 将当前线程 中断，或者到达超时时间。
else if (timed) {
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
LockSupport.parkNanos(this, nanos);
}
else
//当前get操作的线程就会被park了。 线程状态会变为 WAITING状态，相当于休眠了..
//除非有其它线程将你唤醒 或者 将当前线程 中断。
LockSupport.park(this);
}
}
private void removeWaiter(WaitNode node) {
if (node != null) {
node.thread = null;
retry:
for (;;) { // restart on removeWaiter race
for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
s = q.next;
if (q.thread != null)
pred = q;
else if (pred != null) {
pred.next = s;
if (pred.thread == null) // check for race
continue retry;
}
else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,
q, s))
continue retry;
}
break;
}
}
}
/**
* 返回结果或引发已完成任务的异常。
*/
private V report(int s) throws ExecutionException {
//正常情况下，outcome 保存的是callable运行结束的结果
//非正常，保存的是 callable 抛出的异常。
Object x = outcome;
if (s == NORMAL)
return (V)x;
if (s >= CANCELLED)
throw new CancellationException();
throw new ExecutionException((Throwable)x);
｝
FutureTask中Cancel方法
/**
* mayInterruptIfRunning为true，该task正在执行，这个task应该被中断;
* mayInterruptIfRunning为false，该task正在执行，这个task将会继续执行到完成。
*/
public boolean cancel(boolean mayInterruptIfRunning) {
//条件一：state == NEW 成立 表示当前任务处于运行中 或者 处于线程池 任务队列中..
//条件二：UNSAFE.compareAndSwapInt(this, stateOffset, NEW, mayInterruptIfRunning ? INTERRUPTING : CANCELLED))
// 条件成立：说明修改状态成功，可以去执行下面逻辑了，否则 返回false 表示cancel失败。
if (!(state == NEW &&
UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
return false;
try { // in case call to interrupt throws exception
if (mayInterruptIfRunning) {
try {
//执行当前FutureTask 的线程，有可能现在是null，是null 的情况是： 当前任务在 队列中，还没有线程获取到它呢。。
Thread t = runner;
if (t != null)
t.interrupt();
} finally { // final state
UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
}
}
} finally {
finishCompletion();
}
return true;
}
