Runnable和Callable是多執行緒中的兩個任務介面，實作介面的類將擁有多執行緒的功能，FutureTask類與這兩個類是息息相關！

FutureTask繼承體系

看下這張圖，原來FutureTask類實作了Runnable和Future，既然是Runnable的實作類，我們可以寫如下的代碼：

public static void main(String[] args) {

    FutureTask task = new FutureTask(new Callable() {
        @Override
        public Object call() throws Exception {
            System.out.println(Thread.currentThread().getName() + "========>正在執行！");
            return "SUCCESS";
        }
    });

    new Thread(task).start();

}

因為FutureTask是Runnable的實作類嘛，根據多型的特性，肯定可以傳到Thread的構造器中，

FutureTask的構造方法

構造方法1 接收Callable物件

public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}

構造方法2 接收Runnable物件和一個泛型的result

public FutureTask(Runnable runnable, V result) {
    this.callable = Executors.callable(runnable, result);
    this.state = NEW;       // ensure visibility of callable
}

原來，FutureTask內部維護Callable型別的成員變數，對于Callable任務，直接賦值即可，而對于Runnable任務，需要先呼叫Executors#callable()把Runnable先包裝成Callable，

Executors.callable(runnable, result);

這行代碼用了配接器模式，你給我一個runnable物件，我還你一個callable物件，

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

RunnableAdapter是Executors中的靜態內部類，上面代碼意思是呼叫該靜態內部類的構造方法，生成RunnableAdapter物件，而RunnableAdapter物件實作了Callable介面，根據多型也就相當于得到了一個Callable物件，

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;
    }
}

RunnableAdapter作為Callable的配接器，也擁有call方法，這就是配接器模式，

如果你是用第二種方式來構造FutureTask物件，因為傳入的是Runnable，Runnable的run方法是沒有回傳值的，而Callable的call方法是有回傳值的，所以這邊就折中一下，回傳值需要你在構建FutureTask物件時自己傳進去，最后再原封不動地還給你，

如果你是用第一種方式來構造FutureTask物件，那就簡單多了，直接傳入一個Callable物件即可，回傳值你自己決定，

總而言之，FutureTask的構造方法就為了做一件事，即統一Callable和Runnable！

為什么FutureTask要花這么大的精力去搞定Callable和Runnable呢？就是因為統一了好辦事啊，以后在執行緒池的章節中，你還會頻繁看到這個類，

捋一捋思路，為什么要用FutureTask？

多執行緒是Java進階的難點，也是面試的重災區，請確保你把上面的代碼都理解了之后再來看這一節，

我們再回過頭來想想，如何使用多執行緒呢，是不是有3個方法？如果記不得了請回過去看看上一個章節【執行緒類】，

第1種方法是直接繼承Thread類，重寫run方法，

第2種方法是實作Runnable介面，然后還是要靠Thread類的構造器，把Runnable傳進去，最終呼叫的就是Runnable的run方法，

第3種方法是用執行緒池技術，用ExecutorService去提交Runnable物件/Callable物件，區別是Runnable沒有回傳值，Callable物件有回傳值，

你發現沒有，不管你用哪種方式，最終都是要靠Thread類去開啟執行緒的，因為，有且僅有Thread類能通過start0()方法向作業系統申請執行緒資源（本地方法）

第一種方法因為耦合性太高，很少會使用，實際開發中我們一般都會使用執行緒池技術，所以第3種方法是有實戰意義的，那么問題來了，Runnable和Callable物件都可以被用作執行緒池的任務，就有人會亂用了啊，有的人喜歡Runnable，有的喜歡Callable，到時候專案的代碼就亂成一鍋粥啦！

所以，我私以為Java的創始人意識到這一點，就干脆搞一個FutureTask出來一統江湖，我說的這么白，應該都明白了吧，嘿嘿，

FutureTask的7種狀態

既然FutureTask是子類，那么必然有比Callable和Runnable強悍的地方，比如FutureTask的7種狀態

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;

狀態含義分別是：

● 0-剛創建

● 1-即將完成

● 2-完成

● 3-拋例外

● 4-任務取消

● 5-任務即將被打斷

● 6-任務被打斷

為什么要設定這些狀態呢，那是因為FutureTask=任務+結果，呼叫者何時可以去獲取這個結果result呢？FutureTask在呼叫get方法時，會去判斷當前任務的狀態，只有當任務完成才會給你實際的result，因此get方法是阻塞的，

FutureTask的get() 方法

先看下FutureTask的get() 方法是如何使用的：

FutureTask task = new FutureTask(new Callable() {
    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName() + "========>正在執行！");
        Thread.sleep(2000); //執行耗時操作
        return "SUCCESS";
    }
});

new Thread(task).start();

System.out.println(task.get());

效果：

Thread-0========>正在執行！
SUCCESS

過了兩秒后才列印出SUCCESS，說明get確實是阻塞的，再來一個執行緒池的例子：

ExecutorService executorService = Executors.newSingleThreadExecutor();

/**
 * 往執行緒池中提交一個Callable，立刻回傳Future物件，但是該Future物件里面的回傳值目前還是null
 * 只有當你呼叫get方法時，才會阻塞地獲取該任務真實的回傳值
 */
Future<Object> objectFuture = executorService.submit(new Callable<Object>() {
    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName() + "========>正在執行！");
        Thread.sleep(2000); //執行耗時操作
        return "SUCCESS";
    }
});

Object result = objectFuture.get();
System.out.println(result);
executorService.shutdownNow();

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);
    }
}

FutureTask的run方法第一步果然是獲取callable物件，這個callable物件也可能是runnable偽裝的，上面介紹了配接器模式，這邊就不再贅述了，

最終是存盤到outcome物件了，簡而言之，FutureTask的run方法的作用就是運行callable的call方法，拿到回傳值保存到outcome物件，等待有人來取，

薛定諤的FutureTask

為什么說是薛定諤的FutureTask呢？那是因為，當你把FutureTask跑起來的時候，里面的outcome可能沒有值，也可能有值，

但是又因為outcome在FutureTask原始碼中被設定成private，所以如果你要獲取這個資料，只能通過get方法，而get方法是阻塞的，當你呼叫get方法時，一定是等到任務執行成功后，才會回傳真實的值，

這就有點像薛定諤的貓，你不去觀察它，兩種狀態皆有可能，一旦你去觀察了（呼叫get方法），就只有一種明確的狀態，

其實這真的只是一個小技巧，相信你也能辦到，我們用代碼來模擬一下這個程序，

首先，新建一個MyFutureTask類：

/**
 * 自定義任務類
 */
public class MyFutureTask implements Runnable{

    /**
     * 為了看到效果，outcome設定為Object
     */
    public Object outcome;

    public void run(){
        try {
            /**
             * 執行耗時操作
             */
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        /**
         * 給outcome賦值
         */
        this.outcome = "SUCCESS";
    }

    public Object get(){
        return outcome;
    }

}

為了模擬執行緒池，新建一個MyExecutorService類：

class MyExecutorService {

    /**
     * 提交任務
     * @param myFutureTask
     * @return
     */
    public MyFutureTask submit(MyFutureTask myFutureTask){
        /**
         * 開啟一個執行緒把myFutureTask跑掉
         */
        new Thread(myFutureTask).start();
        /**
         * 執行緒有沒有跑完不關心，直接把myFutureTask回傳
         * 此時myFutureTask很可能不是最終結果，但其中的outcome一定指向最終結果
         */
        return myFutureTask;
    }
}

測驗：

public static void main(String[] args) throws InterruptedException {
    MyExecutorService myExecutorService = new MyExecutorService();
    MyFutureTask myFutureTask = myExecutorService.submit(new MyFutureTask());
    /**
     * 執行緒開啟立刻查看outcome
     */
    System.out.println(myFutureTask.outcome);
    /**
     * 主執行緒繼續運作
     */
    Thread.sleep(1100);
    /**
     * 再次查看outcome是否有值
     */
    System.out.println(myFutureTask.get());
}

結果：

null
SUCCESS

總結一下，ExecutorService的submit方法只是提交Runnable或Callable任務到執行緒池，直接回傳FutureTask給你，這個FutureTask是薛定諤的FutureTask，里面的outcome現在可能有值，也可能沒有，只有當你主動呼叫get方法，才可以得到確切的值，

FutureTask的get方法阻塞原理

FutureTask的get方法是阻塞的，當你呼叫這個方法就一定要等該執行緒跑完，那么為什么能做到這樣呢？

接下來我們看看get方法的阻塞原理是什么，我重新寫了一個例子，注釋能寫的都寫了，代碼如下：

package com.javaxbfs.thread;

import java.util.concurrent.locks.LockSupport;

class MyExecutorService {

  /**
     * 提交任務
     * @param myFutureTask
     * @return
     */
    public MyFutureTask submit(MyFutureTask myFutureTask){
      /**
         * 開啟一個執行緒把myFutureTask跑掉
         */
        Thread thread = new Thread(myFutureTask);
        thread.start();
      /**
         * 把執行緒賦給myFutureTask的runner屬性，以方便查看執行緒狀態
         */
        myFutureTask.runner = thread;
      /**
         * 執行緒有沒有跑完不關心，直接把myFutureTask回傳
         * 此時myFutureTask很可能不是最終結果，但其中的outcome一定指向最終結果
         */
        return myFutureTask;
    }
}

/**
 * 自定義任務類
 */
public class MyFutureTask implements Runnable{

  /**
     * 為了看到效果，outcome設定為Object
     */
    public Object outcome;
  /**
     * 當前任務所在的執行緒
     */
    public volatile Thread runner;

    public void run(){
        try {

          /**
             * 執行耗時操作
             */
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
      /**
         * 給outcome賦值
         */
        this.outcome = "SUCCESS";
    }

    public Object get() throws InterruptedException {
        if(awaitDone())
            return outcome;
        return null;
    }

    private boolean awaitDone() throws InterruptedException {
      /**
         * 做一個死回圈，輪詢檢查當前執行緒狀態
         */
        for(;;){
          /**
             * 如果當前執行緒被打斷，則拋例外結束任務
             */
            if(runner.isInterrupted()){
                throw new InterruptedException();
            }
            if(runner.getState() == Thread.State.NEW){
                System.out.println(Thread.currentThread().getName() + "新建！");
            }
            if(runner.getState() == Thread.State.RUNNABLE){
                System.out.println(Thread.currentThread().getName() + "準備就緒！");
            }

            if(runner.getState() == Thread.State.TERMINATED){
                System.out.println(Thread.currentThread().getName() + "執行完畢！");
                return true;
            }
            Thread.sleep(200);
        }
    }


    public static void main(String[] args) throws InterruptedException {
        MyExecutorService myExecutorService = new MyExecutorService();
        MyFutureTask myFutureTask = myExecutorService.submit(new MyFutureTask());
      /**
         * 執行緒開啟立刻查看outcome
         */
        System.out.println(myFutureTask.outcome);
      /**
         * 主執行緒繼續運作
         */
        //Thread.sleep(1100);
      /**
         * 再次查看outcome是否有值,現在是阻塞的
         */
        System.out.println(myFutureTask.get());
    }
}

關鍵就在于這個 awaitDone 方法（原始碼也叫這個名字），它里面是一個死回圈，不斷去檢查當前FutureTask所在執行緒的狀態，當執行緒執行結束，就回傳true，表示可以給出精確的result了，

真實的get方法實作非常復雜，不過思路是差不多的，有興趣的童鞋可以去百度了解，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/353131.html

標籤：Java

上一篇：Docker 部署前后端專案

下一篇：升級JDK8的坎坷之路

淺談Java多執行緒之FutureTask