并發編程：你真的了解FutureTask嗎？
作者：斯巴達人
FutureTask就是一個實現了一套獲取返回值機制的任務體，請注意它依然是任務體，自身不能執行任務，依然需要借助Thread執行。
FutureTask是什么
public interface Runnable {
public abstract void run();
}
Student implements Runnable
Thread xiaoming = new Thread(new Student());
xiaoming.start();我們知道Runnable是一個接口，它用來承載的是具體的任務，交給Thread執行。
有這樣一個場景：主線程執行一個任務（理解為調用一個方法）需要獲取這個任務的返回值，然后再去執行另一個任務獲取返回值，最后將兩個返回值做其他處理，一般情況下耗時為兩個任務的耗時和，如果想提高性能，可以用異步的方式，可以將任務一包裝為Runnable，交給子線程執行，主線程執行第二個任務，這樣就節省了一部分耗時，但是Runnable不支持返回值，所以行不通，而FutureTask就是解決這個問題的。
FutureTask的類圖如下：
看圖可以知道兩個事：
- 實現了Runnable接口，所以FutureTask也是一個可以承載任務的任務類。
- 實現了Future接口，Future接口提供了任務操作和獲取返回值等方法，利用Future接口可以獲取任務執行狀態，取消任務，獲取任務返回值等。
所以說FutureTask就是一個實現了一套獲取返回值機制的任務體，請注意它依然是任務體，自身不能執行任務，依然需要借助Thread執行。
FutureTask應用例子
Callable<Integer> callableTask = () -> {
// 一些耗時的計算
return 42;
};
FutureTask<Integer> futureTask = new FutureTask<>(callableTask);
Thread thread = new Thread(futureTask);
thread.start();
try {
Integer result = futureTask.get(); // 阻塞直到任務完成并返回結果
System.out.println("任務結果：" + result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}上面就是使用案例，看起來寫法比較復雜，其實一旦理解就不復雜了，首先我們上面說了FutureTask實現了Runnable，所以它是任務體，任務體需要依賴Thread執行，所以這里FutureTask和Runnable的寫法一樣都是作為Thread的入參。
代碼中可以看到還有一個Callable類，這個其實也是任務體，它的源碼如下：
public interface Callable<V> {
V call() throws Exception;
}它是一個有返回值的任務體，但是它和Runnable不同，Runnable是和Thread綁定的官方任務體，而Callable只是為達到實現獲取任務返回值而衍生出來的一個任務體，它主要作為FutureTask類中的一個成員屬性，充當真正被執行的任務體。
FutureTask源碼分析
先看下FutureTask主要的屬性和構造方法：
public class FutureTask<V> implements RunnableFuture<V> {
private volatile int state;
//等待執行狀態 初始狀態
private static final int NEW = 0;
//執行完畢狀態，但是結果還沒有填充到outcome
private static final int COMPLETING = 1;
//返回值填充outcome 正常結束任務狀態
private static final int NORMAL = 2;
//因異常而結束
private static final int EXCEPTIONAL = 3;
//任務還未執行之前就調用了cancel(true)方法
private static final int CANCELLED = 4;
//中斷的中間狀態
private static final int INTERRUPTING = 5;
//中斷的狀態
private static final int INTERRUPTED = 6;
private Callable<V> callable;
private Object outcome;
private volatile Thread runner;
private volatile WaitNode waiters;
static final class WaitNode {
volatile Thread thread;
volatile WaitNode next;
WaitNode() {
thread = Thread.currentThread();
}
}
protected void done() { }
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW;
}
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW;
}- state是狀態，沒到一個階段都是不同的狀態。
- outcome是存放返回值的，當任務執行完返回的值會賦值給outcome
- callable是真正的任務體，run方法在運行的時候實際上是運行callable對象的call方法。
- waiters是線程阻塞等待結果的時候存放的隊列，它的類型是WaitNode，WaitNode里面有一個next屬性，可見它是一個單向鏈表結構。
- runner是當前正在執行任務的線程
- done方法在FutureTask里面沒有具體實現，它是任務處理完的一個后置方法，是留給子類用的。
- 構造方法一是接收一個Callable對象賦值給成員變量callable。- 構造方法二是接收一個Runnable對象和一個result值，同樣是賦值給callable變量。
構造方法一很容易理解，構造方法二則是接收一個Runnable任務體，但是Runnable沒有返回值，所以再接收一個result值作為默認的返回值，也就是無論任務體的任務執行的結果是什么，都以result值作為固定的返回值。
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;
}
}構造方法二中調用了Executors.callable()方法，這個方法就是將Runnable和result值封裝為RunnableAdapter對象，RunnableAdapter實現了Callable，所以它也是一個Callable對象，所以可以賦值給成員變量callable.
接下來按照應用案例中的步驟跟一下源碼，構造方法我們看了，接下來就是啟動線程，啟動線程就會調用任務體的run方法，我們從run方法開始跟進源碼。
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 {
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}- 判斷狀態，只有當前狀態為待執行狀態，并且能利用cas將當前線程成功賦值給runner，進入下一步。
- 如果成員變量callable不為空，執行任務體callable的call方法并得到返回值result。
- 調用set(result)方法。
protected void set(V v) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}- 將狀態由NEW（待執行狀態）改為COMPLETING(執行完成狀態)。
- 將返回值result賦值給成員變量outcome。
- 將狀態由改為COMPLETING（執行完成狀態）NORMAL(返回值填充完畢狀態)
- 調用finishCompletion（）
private void finishCompletion() {
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;
q = next;
}
break;
}
}
done();
callable = null;
}- 這個方法其實就是喚醒正在等待結果的線程，可能有多個線程在等待任務返回值，等待的線程都會被封裝為一個WaitNode節點，多個節點以單向鏈表結構連接在一起，這個方法是從鏈表的頭節點一個一個喚醒。
將所有的等待線程喚醒后，最后執行done方法，done方法在FutureTask沒有被實現，所以也就相當于什么都不做，那么done存在的意義是什么呢？它存在的意義在于在任務處理的完畢后線程結束前做一些事情，是留給子類擴展用的。
再看futureTask.get()的源碼分析
當前線程是等待任務結果的線程不同于上面執行任務的線程：
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}- 如果此時狀態是返回值填充完畢狀態，那就進入report方法直接返回值即可，如果此時狀態不是返回值填充完畢狀態，就要進入awaitDone方法進行阻塞等待操作。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();
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);
}
}
- 先計算等待時長，結果要么是需要等待一定時長，要么是永久等待。
- 進入循環進行一些力的判斷處理。
- 判斷中斷，如果是被中斷直接出隊并拋異常（外面可以通過捕獲異常讓下城跳出循環）。可見阻塞等待是可以被中斷的。
- 如果此時狀態是大于等于返回值填充完畢狀態直接返回此狀態。
- 如果此時狀態為執行完畢狀態，但是還沒有到達返回值填充完畢狀態，那就讓出cpu稍微等待一下，因為這兩個狀態的間隔很短。
- 如果上面的判斷都不滿足，那就為當前線程綁定WaitNode節點。
- 如果綁定的WaitNode節點還沒有入隊，那就通過cas方式入隊，就是替換頭節點，也就是后進來的為頭節點。
- 如果指定了阻塞時間，此時要判斷是否超時，如果超時就直接返回狀態，如果沒有超時，計算出所剩的時間，然后利用LockSupport.parkNanos阻塞。
- 如果上面都不滿足就利用LockSupport.park進入永久阻塞。
上面就是FutureTask主要的源碼分析，其原理比較簡單，如果是run方法中提供返回值的支持，還有一個方法runAndReset，它提供了任務循環執行的支持。
protected boolean runAndReset() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return false;
boolean ran = false;
int s = state;
try {
Callable<V> c = callable;
if (c != null && s == NEW) {
try {
c.call(); // don't set result
ran = true;
} catch (Throwable ex) {
setException(ex);
}
}
} finally {
s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
return ran && s == NEW;
}這個代碼很簡單，如果狀態為待執行，就會執行任務，不關心返回值，任務執行完不會更新狀態，使得狀態一直處于待執行狀態，如果runAndReset方法被再次調用依然會再一次執行任務。ScheduledThreadPoolExecutor就利用了這個方法實現定時任務處理。
其他方法支持
上面說了FutureTask實現了Future接口，Future接口提供了對任務處理的能力
//獲取任務結果 如果任務沒有處理完就阻塞等待timeout時間
V get(long timeout, TimeUnit unit);
//獲取任務結果 如果任務沒有處理完就永久阻塞等待
V get();
//任務執行完畢后執行的方法，用于子類擴展用
boolean isDone();
//任務是否被取消 true為已取消
boolean isCancelled();
//取消任務
boolean cancel(boolean mayInterruptIfRunning);cancel為取消任務，它有一個boolean類型的參數，true表示需要中斷線程并且將狀態改為INTERRUPTING，false表示只改狀態為CANCELLED。
cancel方法的邏輯如下：
- 只有處于待執行狀態的任務才會被取消
- 傳參為false，狀態由NEW改為CANCELLED
- 傳參為true，狀態由NEW改為INTERRUPTING
- 同時如果傳參是true,則調用負責執行任務的那個線程的interrupt方法進行中斷操作，最后將狀態由INTERRUPTING改為INTERRUPTED
- 喚醒所有正在等待任務結果的線程。
- 最后執行done方法。
責任編輯：趙寧寧
來源：
碼農本農
