java中可以通过继承Thread或者实现Runnable接口来实现多线程，但是这种方式并不能让我们在线程执行完后获取执行结果。因此在java1.5开始引入了Callable和Future接口，通过它们可以在线程执行完后获取执行结果。Callable表示一个可返回结果的任务，Future表示一个异步计算的结果
FutureTask的实现只是依赖了一个内部类Sync实现的，Sync是AQS (AbstractQueuedSynchronizer)的子类，这个类承担了所有future的功能，AbstractQueuedSynchronizer的作者是大名鼎鼎的并发编程大师Doug Lea。
1.类声明
public class FutureTask<V> implements RunnableFuture<V>
FutureTask实现了RunnableFutute接口，RunnableFutute实际上是一个组合接口，由Runnable接口和Future接口组合而成。
public interface RunnableFuture<V> extends Runnable, Future<V> { void run(); } @FunctionalInterface public interface Runnable { /** * Sets this Future to the result of its computation unless it has been cancelled. */ public abstract void run(); } public interface Future<V> { //试图取消对此任务的执行。 boolean cancel(boolean mayInterruptIfRunning); //如果在任务正常完成前将其取消，则返回 true。 boolean isCancelled(); //如果任务已完成，则返回 true。 boolean isDone(); //如有必要，等待计算完成，然后获取其结果。 V get() throws InterruptedException, ExecutionException; //如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）。 V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; }
这里有个值得玩味的地方是：既然RunnableFuture已经继承了Runnable接口，为什么还要再声明一个run()方法？StackOverFlow网站上也有这个问题：Why does java.util.concurrent.RunnableFuture have a run() method? 。点赞最多的答案已经给了我们答复：仅仅是因为jdk的开发者想给run()方法加上新的Doc注释，所以就显式的重新声明一个run()方法，并没有任何技术相关的含义。
2.属性
private volatile int state; //初始状态 private static final int NEW = 0; //任务即将结束状态。该状态是个瞬时状态，之后会进入NORMAL状态或EXCEPTIONAL状态。当结果值outcome被设置后出现该瞬时状态。 private static final int COMPLETING = 1; //任务正常结束状态。 private static final int NORMAL = 2; //任务出现异常结束状态。 private static final int EXCEPTIONAL = 3; //任务被取消结束状态。 private static final int CANCELLED = 4; //任务即将中断状态。也是一个瞬时状态，调用cancel(true)取消任务时会出现该瞬时状态。 private static final int INTERRUPTING = 5; //任务被中断结束状态。 private static final int INTERRUPTED = 6; /** The underlying callable; nulled out after running */ //底层的Callable任务。任务运行结束后会被设置为null。 private Callable<V> callable; /** The result to return or exception to throw from get() */ //任务执行结果：调用get()方法时，返回的结果或者抛出的异常结果。【非volatile，被state的读写方法进行保护】 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 */ //等待节点(Treiber栈结构) private volatile WaitNode waiters;
等待节点使用了Treiber Stack数据结构。
任务的运行总共有如下7种状态：
- NEW：0。任务的初始状态
- COMPLETING：1。任务即将完成状态。该状态是个瞬时状态，之后会立即进入NORMAL状态或EXCEPTIONAL状态。当结果值outcome被设置后出现该瞬时状态。
- NORMAL：2。任务正常完成状态。
- EXCEPTIONAL：3。任务出现异常状态。
- CANCELLED：4。任务被取消的状态。
- INTERRUPTING：5。任务正被中断状态。也是一个瞬时状态，调用cancel(true)取消任务时会出现该瞬时的正被中断状态。
- INTERRUPTED：6。任务被中断状态。
运行状态仅能通过set,setException和cancel方法进行改变。可能发生的状态流转有如下4种情况：
- NEW -> COMPLETING -> NORMAL
- NEW -> COMPLETING -> EXCEPTIONAL
- NEW -> CANCELLED
- NEW -> INTERRUPTING -> INTERRUPTED
用画图表示更一目了然。
3.创建任务
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) { this.callable = Executors.callable(runnable, result); this.state = NEW; // ensure visibility of callable }
我们使用FututeTask通常用来异步执行并获取结果，有执行结果的任务用Callable表示。
4.提交任务
任务需要通过线程或线程池来执行。无论是线程，还是线程池，最后都是会调用线程的start方法来执行任务的。而start方法会调用Thread的run方法，最终执行的是传入的任务的run()方法，也就是FutureTask的run方法，来简单分析一下。通过将FutureTask实例传递给Thread来执行的。
//该处target代表FututeTask实例 new Thread(target).start()；
跟踪一下Thread的源码：Thread内部也有个target属性，上面的Thread构造器最终会将FutureTask实例传递给Thread中的target。再来看看Thread的run()方法，执行的就是传入实例的run方法。
@Override public void run() { if (target != null) { target.run(); } }
5.执行任务-run
执行任务
经过上面的分析，既然线程执行的是FutureTask的run方法，那就来跟踪一下吧。
public void 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(ex); } if (ran) set(result); } } finally { // runner must be non-null until state is settled to // prevent concurrent calls to run() runner = null; // state must be re-read after nulling runner to prevent // leaked interrupts int s = state; if (s >= INTERRUPTING) handlePossibleCancellationInterrupt(s); } }
处理取消中断
/** * Ensures that any interrupt from a possible cancel(true) is only * delivered to a task while in run or runAndReset. */ 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(); }
6.取消任务-cancel
6.1取消任务
public boolean cancel(boolean mayInterruptIfRunning) { if (state != NEW) return false; if (mayInterruptIfRunning) { if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, INTERRUPTING)) return false; Thread t = runner; if (t != null) t.interrupt(); UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED); // final state } else if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, CANCELLED)) return false; finishCompletion(); return true; }
执行该取消操作的线程与任务执行线程自然不是同一个线程。取消任务时，可以同时给任务执行线程下达中断通知，当然也可以不下达，这是通过参数mayInterruptIfRunning来控制的。想想线程池的场景，当取消任务时，线程池中的线程可以继续存活，或者调用者希望将其中断掉。
①如果mayInterruptIfRunning为true，表示取消任务，同时中断任务执行线程。
- 将任务从NEW状态设置为INTERRUPTING瞬时状态，并给任务执行线程下达中断通知，之后将任务状态设置为INTERRUPTED状态。而执行任务的线程检测到中断后，就会响应中断。
②如果mayInterruptIfRunning为false，表示取消任务，但不中断任务执行线程。
- 则将任务状态从New设置为INTERRUPED状态。
完成上面的操作后，会唤醒等待线程(finishCompletion)
6.2唤醒等待线程-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 }
7.获取任务执行结果-get
public V get() throws InterruptedException, ExecutionException { int s = state; 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; if (s <= COMPLETING && (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING) throw new TimeoutException(); //汇报执行结果 return report(s); } 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); }
Treiber Stack数据结构
FututeTask的等待节点是一个Treiber Stack结构。Treiber Stack在 R. Kent Treiber1986年的论文Systems Programming: Coping with Parallelism中首次出现。
可以参考相关文章：
总结
1.Callable和Future代表的含义？
2.Future和FutureTask的区别？
2.FutureTask的应用场景？