摘要：聲明了幾種方法，其中有一個就是傳入聲明了對具體的或者任務執行進行取消查詢結果獲取等方法。事實上，是接口的一個唯一實現類。使用示例第一種方式是使用繼承了的線程池中的方法，將直接提交創建。

直接繼承 Thread

實現 Runnable 接口

這兩種方式都有一個缺點：在執行完成任務之后，無法直接獲取到最后的執行結果。如果需要獲取執行結果，就必須通過共享變量或線程通信的方式來達到想要的效果，較為麻煩。

所以從 Java 1.5 起，就提供了兩種方式：Callable 和 Future，通過它們可以在任務執行結束后得到任務執行結果。

首先是 java.lang.Rannable，它是一個接口，里面只聲明了一個 run() 方法：

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

由于 run() 方法的返回值類型為 void，所以在線程執行完后無任何返回結果。

然后是 java.util.concurrent.Callable，它也是一個接口，也只聲明了一個方法，其名為 call()：

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

可以看到，這是一個泛型接口，返回的類型就是傳進來的 V 類型。

那么，如何使用 Callable 呢？一般是結合 ExecutorService 來使用。ExecutorService 聲明了幾種 submit 方法，其中有一個就是傳入 Callable：

 Future submit(Callable task);

Future 聲明了對具體的 Runnable 或者 Callable 任務執行進行取消、查詢、結果獲取等方法。必要時可以通過 get 方法獲取執行結果，該方法會阻塞直到任務返回結果。

public interface Future {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

由此可見，Future 提供了三種功能：

取消任務：參數表示是否允許中途取消（中斷）

判斷狀態：是否已取消、是否已完成

獲取結果：兩種方式，指不指定時間

因為 Future 只是一個接口，所以無法直接用來創建對象，因此有了下面的 FutureTask。

首先看下 FutureTask 的繼承關系：

可以看出 RunnableFuture 繼承了 Runnable 接口和 Future 接口，而 FutureTask 實現了 RunnableFuture 接口。所以它既可以作為 Runnable 被線程執行，又可以作為 Future 得到 Callable 的返回值。

然后可以看到 FutureTask 內部有這幾種狀態：

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;

再根據注釋，可以得知當創建一個 FutureTask 對象時，初始狀態是 NEW，在運行過程中，運行狀態僅在方法set，setException 和 cancel 中轉換為終端狀態。有四種狀態轉換過程：

NEW -> COMPLETING -> NORMAL：正常執行并返回結果（run 執行成功再設置狀態為 COMPLETING）

NEW -> COMPLETING -> EXCEPTIONAL：執行過程中出現異常（setException 先設置狀態為 COMPLETING）

NEW -> CANCELLED：執行前被取消

NEW -> INTERRUPTING -> INTERRUPTED：執行時被中斷（cancel 參數為 true 才可能出現這個狀態）

最后來看下 FutureTask 的兩個構造器：

public FutureTask(Callable 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
}

可知傳入的任務最后都是付給內部的 private Callable callable。

事實上，FutureTask 是 Future 接口的一個唯一實現類。

更多關于 FutureTask 的源碼分析，可以看 FutureTask源碼解析 這篇文章。

第一種方式是使用繼承了 ExecutorService 的線程池 ThreadPoolExecutor 中的 submit 方法，將 Callable 直接提交創建 Future。

import java.util.concurrent.*;
public class FutureExample {
    static class MyCallable implements Callable {
        @Override
        public String call() throws Exception {
            System.out.println("do something in callable");
            Thread.sleep(5000);
            return "Ok";
        }
    }
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Future future = executorService.submit(new MyCallable());
        System.out.println("do something in main");
        Thread.sleep(1000);
        String result = future.get();
        System.out.println("result: " + result);
    }
}

第二種方法是創建一個寫好 Callable 的 FutureTask 對象實例，再 submit。因為 FutureTask 內部本身擁有 run 方法，也可以直接創建線程 Thread 運行。

利用 ExecutorService

import java.util.concurrent.*
public class FutureTaskWithExecutorService {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        FutureTask futureTask = new FutureTask<>(() -> { // java 8 函數式寫法
            System.out.println("do something in callable");
            Thread.sleep(5000);
            return "Ok";
        });
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.submit(futureTask);
        System.out.println("do something in main");
        Thread.sleep(1000);
        String result = futureTask.get();
        System.out.println("result: " + result);
    }
}

利用 Thread

import java.util.concurrent.*
public class FutureTaskWithThread {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        FutureTask futureTask = new FutureTask<>(new Callable() {
            @Override
            public String call() throws Exception {
                System.out.println("do something in callable");
                Thread.sleep(5000);
                return "Ok";
            }
        });
        new Thread(futureTask).start();
        System.out.println("do something in main");
        Thread.sleep(1000);
        String result = futureTask.get();
        System.out.println("result: " + result);
    }
}

Java并發編程：Callable、Future和FutureTask

FutureTask源碼解析