FutureTask是什么

public interface Runnable {
    public abstract void run();
}

Student implements Runnable

Thread xiaoming = new Thread(new Student());

xiaoming.start();

我們知道Runnable是一個接口，它用來承載的是具體的任務(wù)，交給Thread執(zhí)行。

創(chuàng)新互聯(lián)建站主要從事網(wǎng)站制作、成都網(wǎng)站設(shè)計、網(wǎng)頁設(shè)計、企業(yè)做網(wǎng)站、公司建網(wǎng)站等業(yè)務(wù)。立足成都服務(wù)澄江,十年網(wǎng)站建設(shè)經(jīng)驗,價格優(yōu)惠、服務(wù)專業(yè),歡迎來電咨詢建站服務(wù):028-86922220

有這樣一個場景：主線程執(zhí)行一個任務(wù)（理解為調(diào)用一個方法）需要獲取這個任務(wù)的返回值，然后再去執(zhí)行另一個任務(wù)獲取返回值，最后將兩個返回值做其他處理，一般情況下耗時為兩個任務(wù)的耗時和，如果想提高性能，可以用異步的方式，可以將任務(wù)一包裝為Runnable，交給子線程執(zhí)行，主線程執(zhí)行第二個任務(wù)，這樣就節(jié)省了一部分耗時，但是Runnable不支持返回值，所以行不通，而FutureTask就是解決這個問題的。

FutureTask的類圖如下：

看圖可以知道兩個事：

• 實現(xiàn)了Runnable接口，所以FutureTask也是一個可以承載任務(wù)的任務(wù)類。
• 實現(xiàn)了Future接口，F(xiàn)uture接口提供了任務(wù)操作和獲取返回值等方法，利用Future接口可以獲取任務(wù)執(zhí)行狀態(tài)，取消任務(wù)，獲取任務(wù)返回值等。

所以說FutureTask就是一個實現(xiàn)了一套獲取返回值機制的任務(wù)體，請注意它依然是任務(wù)體，自身不能執(zhí)行任務(wù)，依然需要借助Thread執(zhí)行。

FutureTask應(yīng)用例子

Callable callableTask = () -> {
    // 一些耗時的計算
    return 42;
};

FutureTask futureTask = new FutureTask<>(callableTask);
Thread thread = new Thread(futureTask);
thread.start();

try {
    Integer result = futureTask.get(); // 阻塞直到任務(wù)完成并返回結(jié)果
    System.out.println("任務(wù)結(jié)果：" + result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

上面就是使用案例，看起來寫法比較復(fù)雜，其實一旦理解就不復(fù)雜了，首先我們上面說了FutureTask實現(xiàn)了Runnable，所以它是任務(wù)體，任務(wù)體需要依賴Thread執(zhí)行，所以這里FutureTask和Runnable的寫法一樣都是作為Thread的入?yún)ⅰ?/p>

代碼中可以看到還有一個Callable類，這個其實也是任務(wù)體，它的源碼如下：

public interface Callable {
    V call() throws Exception;
}

它是一個有返回值的任務(wù)體，但是它和Runnable不同，Runnable是和Thread綁定的官方任務(wù)體，而Callable只是為達到實現(xiàn)獲取任務(wù)返回值而衍生出來的一個任務(wù)體，它主要作為FutureTask類中的一個成員屬性，充當(dāng)真正被執(zhí)行的任務(wù)體。

FutureTask源碼分析

先看下FutureTask主要的屬性和構(gòu)造方法：

public class FutureTask implements RunnableFuture {
    private volatile int state;
    //等待執(zhí)行狀態(tài) 初始狀態(tài)
    private static final int NEW          = 0;
    //執(zhí)行完畢狀態(tài)，但是結(jié)果還沒有填充到outcome
    private static final int COMPLETING   = 1;
    //返回值填充outcome 正常結(jié)束任務(wù)狀態(tài)
    private static final int NORMAL       = 2;
    //因異常而結(jié)束
    private static final int EXCEPTIONAL  = 3;
    //任務(wù)還未執(zhí)行之前就調(diào)用了cancel(true)方法
    private static final int CANCELLED    = 4;
    //中斷的中間狀態(tài)
    private static final int INTERRUPTING = 5;
    //中斷的狀態(tài)
    private static final int INTERRUPTED  = 6;

    private Callable 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 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是狀態(tài)，沒到一個階段都是不同的狀態(tài)。
• outcome是存放返回值的，當(dāng)任務(wù)執(zhí)行完返回的值會賦值給outcome
• callable是真正的任務(wù)體，run方法在運行的時候?qū)嶋H上是運行callable對象的call方法。
• waiters是線程阻塞等待結(jié)果的時候存放的隊列，它的類型是WaitNode，WaitNode里面有一個next屬性，可見它是一個單向鏈表結(jié)構(gòu)。
• runner是當(dāng)前正在執(zhí)行任務(wù)的線程
• done方法在FutureTask里面沒有具體實現(xiàn)，它是任務(wù)處理完的一個后置方法，是留給子類用的。
• 構(gòu)造方法一是接收一個Callable對象賦值給成員變量callable。- 構(gòu)造方法二是接收一個Runnable對象和一個result值，同樣是賦值給callable變量。

構(gòu)造方法一很容易理解，構(gòu)造方法二則是接收一個Runnable任務(wù)體，但是Runnable沒有返回值，所以再接收一個result值作為默認的返回值，也就是無論任務(wù)體的任務(wù)執(zhí)行的結(jié)果是什么，都以result值作為固定的返回值。

public static  Callable callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter(task, result);
    }

 static final class RunnableAdapter implements Callable {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

構(gòu)造方法二中調(diào)用了Executors.callable()方法，這個方法就是將Runnable和result值封裝為RunnableAdapter對象，RunnableAdapter實現(xiàn)了Callable，所以它也是一個Callable對象，所以可以賦值給成員變量callable.

接下來按照應(yīng)用案例中的步驟跟一下源碼，構(gòu)造方法我們看了，接下來就是啟動線程，啟動線程就會調(diào)用任務(wù)體的run方法，我們從run方法開始跟進源碼。

run方法源碼分析

 public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
            return;
        try {
            Callable 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);
        }
    }

1. 判斷狀態(tài)，只有當(dāng)前狀態(tài)為待執(zhí)行狀態(tài)，并且能利用cas將當(dāng)前線程成功賦值給runner，進入下一步。
2. 如果成員變量callable不為空，執(zhí)行任務(wù)體callable的call方法并得到返回值result。
3. 調(diào)用set(result)方法。

 protected void set(V v) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = v;
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
            finishCompletion();
        }
    }

1. 將狀態(tài)由NEW（待執(zhí)行狀態(tài)）改為COMPLETING(執(zhí)行完成狀態(tài))。
2. 將返回值result賦值給成員變量outcome。
3. 將狀態(tài)由改為COMPLETING（執(zhí)行完成狀態(tài)）NORMAL(返回值填充完畢狀態(tài))
4. 調(diào)用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;       
    }

1. 這個方法其實就是喚醒正在等待結(jié)果的線程，可能有多個線程在等待任務(wù)返回值，等待的線程都會被封裝為一個WaitNode節(jié)點，多個節(jié)點以單向鏈表結(jié)構(gòu)連接在一起，這個方法是從鏈表的頭節(jié)點一個一個喚醒。

將所有的等待線程喚醒后，最后執(zhí)行done方法，done方法在FutureTask沒有被實現(xiàn)，所以也就相當(dāng)于什么都不做，那么done存在的意義是什么呢？它存在的意義在于在任務(wù)處理的完畢后線程結(jié)束前做一些事情，是留給子類擴展用的。

再看futureTask.get()的源碼分析

當(dāng)前線程是等待任務(wù)結(jié)果的線程不同于上面執(zhí)行任務(wù)的線程：

 public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }

1. 如果此時狀態(tài)是返回值填充完畢狀態(tài)，那就進入report方法直接返回值即可，如果此時狀態(tài)不是返回值填充完畢狀態(tài)，就要進入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);
        }
    }

1. 先計算等待時長，結(jié)果要么是需要等待一定時長，要么是永久等待。
2. 進入循環(huán)進行一些力的判斷處理。
3. 判斷中斷，如果是被中斷直接出隊并拋異常（外面可以通過捕獲異常讓下城跳出循環(huán)）。可見阻塞等待是可以被中斷的。
4. 如果此時狀態(tài)是大于等于返回值填充完畢狀態(tài)直接返回此狀態(tài)。
5. 如果此時狀態(tài)為執(zhí)行完畢狀態(tài)，但是還沒有到達返回值填充完畢狀態(tài)，那就讓出cpu稍微等待一下，因為這兩個狀態(tài)的間隔很短。
6. 如果上面的判斷都不滿足，那就為當(dāng)前線程綁定WaitNode節(jié)點。
7. 如果綁定的WaitNode節(jié)點還沒有入隊，那就通過cas方式入隊，就是替換頭節(jié)點，也就是后進來的為頭節(jié)點。
8. 如果指定了阻塞時間，此時要判斷是否超時，如果超時就直接返回狀態(tài)，如果沒有超時，計算出所剩的時間，然后利用LockSupport.parkNanos阻塞。
9. 如果上面都不滿足就利用LockSupport.park進入永久阻塞。

上面就是FutureTask主要的源碼分析，其原理比較簡單，如果是run方法中提供返回值的支持，還有一個方法runAndReset，它提供了任務(wù)循環(huán)執(zhí)行的支持。

protected boolean runAndReset() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return false;
        boolean ran = false;
        int s = state;
        try {
            Callable 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;
    }

這個代碼很簡單，如果狀態(tài)為待執(zhí)行，就會執(zhí)行任務(wù)，不關(guān)心返回值，任務(wù)執(zhí)行完不會更新狀態(tài)，使得狀態(tài)一直處于待執(zhí)行狀態(tài)，如果runAndReset方法被再次調(diào)用依然會再一次執(zhí)行任務(wù)。ScheduledThreadPoolExecutor就利用了這個方法實現(xiàn)定時任務(wù)處理。

其他方法支持

上面說了FutureTask實現(xiàn)了Future接口，F(xiàn)uture接口提供了對任務(wù)處理的能力

//獲取任務(wù)結(jié)果 如果任務(wù)沒有處理完就阻塞等待timeout時間
V get(long timeout, TimeUnit unit);
//獲取任務(wù)結(jié)果 如果任務(wù)沒有處理完就永久阻塞等待
V get(); 
//任務(wù)執(zhí)行完畢后執(zhí)行的方法，用于子類擴展用
boolean isDone();
//任務(wù)是否被取消 true為已取消
boolean isCancelled();
//取消任務(wù)
boolean cancel(boolean mayInterruptIfRunning);

cancel為取消任務(wù)，它有一個boolean類型的參數(shù)，true表示需要中斷線程并且將狀態(tài)改為INTERRUPTING，false表示只改狀態(tài)為CANCELLED。

cancel方法的邏輯如下：

1. 只有處于待執(zhí)行狀態(tài)的任務(wù)才會被取消
2. 傳參為false，狀態(tài)由NEW改為CANCELLED
3. 傳參為true，狀態(tài)由NEW改為INTERRUPTING
4. 同時如果傳參是true,則調(diào)用負責(zé)執(zhí)行任務(wù)的那個線程的interrupt方法進行中斷操作，最后將狀態(tài)由INTERRUPTING改為INTERRUPTED
5. 喚醒所有正在等待任務(wù)結(jié)果的線程。
6. 最后執(zhí)行done方法。

分享標(biāo)題：并發(fā)編程：你真的了解FutureTask嗎？
網(wǎng)站路徑：http://uogjgqi.cn/article/dhcposh.html