摘要：使用獲得返回結果新建個線程，每個線程分別負責累加慢速累加器線程等待線程執行完畢累加的結果運行結束，結果為運行結果第二種方法使用和。

Java 對多線程編程提供了內置的支持并提供了良好的 API，通過使用 Thread 和 Runnable 兩個基礎類，我們可以很方便的創建一個線程：

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("線程啟動");
        // 耗時操作
        System.out.println("線程結束");
    }
};

Thread thread = new Thread(runnable); // 創建線程，runnable 作為線程要執行的任務（載體）
thread.start(); // 啟動線程
thread.join(); // 等待線程執行完畢

{ 題外話開始：

通過 Thread 的類聲明：

我們可以知道 Thread 自己也實現了 Runnable 接口，Thread 中 run 方法的實現如下（Thread 啟動之后運行的就是 Thread 中的 run 方法）：

（target 即構造 Thread 時可傳入的 Runnable 對象，不傳入即為 null —— 所以繼承 Thread 重寫其 run 方法也是一種創建線程的方式）

題外話結束 }

Runnable.java 的代碼：

Runnable 的 run 方法是不帶返回值的，那如果我們需要一個耗時任務在執行完之后給予返回值，應該怎么做呢？

第一種方法：在 Runnable 的實現類中設置一個變量 V，在 run 方法中將其改變為我們期待的結果，然后通過一個 getV() 方法將這個變量返回。

import java.util.*;

public class RunnableTest {

    public static void main(String[] args) throws Exception {
        System.out.println("使用 Runnable 獲得返回結果：");

        List workers = new ArrayList<>(10);
        List tasks = new ArrayList<>(10);

        // 新建 10 個線程，每個線程分別負責累加 1~10, 11~20, ..., 91~100
        for (int i = 0; i < 10; i++) {
            AccumRunnable task = new AccumRunnable(i * 10 + 1, (i + 1) * 10);
            Thread worker = new Thread(task, "慢速累加器線程" + i);

            tasks.add(task);
            workers.add(worker);

            worker.start();
        }

        int total = 0;
        for (int i = 0, s = workers.size(); i < s; i++) {
            workers.get(i).join();  // 等待線程執行完畢
            total += tasks.get(i).getResult();
        }

        System.out.println("
累加的結果: " + total);
    }

    static final class AccumRunnable implements Runnable {

        private final int begin;
        private final int end;

        private int result;

        public AccumRunnable(int begin, int end) {
            this.begin = begin;
            this.end = end;
        }

        @Override
        public void run() {
            result = 0;
            try {
                for (int i = begin; i <= end; i++) {
                    result += i;
                    Thread.sleep(100);
                }
            } catch (InterruptedException ex) {
                ex.printStackTrace(System.err);
            }
            System.out.printf("(%s) - 運行結束，結果為 %d
",
                    Thread.currentThread().getName(), result);
        }

        public int getResult() {
            return result;
        }
    }

}

運行結果：

第二種方法：使用 Callable 和 FutureTask。
Callable 是 JDK1.5 時添加的類，為的就是解決 Runnable 的痛點（沒有返回值和不能拋出異常）。

Callable.java 的代碼：

可以看到參數化類型 V 就是返回的值的類型。

但是查看 Thread 的構造方法，我們發現 Thread 只提供了將 Runnable 作為參數的構造方法，并沒有使用 Callable 的構造方法 —— 所以引出 FutureTask。

FutureTask 也是 JDK1.5 時添加的類，查看它的類聲明：

可以看到它實現了 RunnableFuture 這個接口，我們再看看 RunnableFuture：

可以看到 RunnableFuture 接口繼承了 Runnable 接口，那么 RunnableFuture 接口的實現類 FutureTask 必然會去實現 Runnable 接口 —— 所以 FutureTask 可以用來當 Runnable 使用。查看 FutureTask 的構造方法，發現 FutureTask 有兩個構造方法：

第一個構造方法表明我們可以通過一個 Callable 去構造一個 FutureTask —— 而 FutureTask 實現了 Runnable 接口，從而可以將該任務傳遞給 Thread 去運行；

第二個構造方法是通過一個 Runnable 和一個指定的 result 去構造 FutureTask。

我們再來看看 FutureTask 通過 RunnableFuture 實現的第二個接口：Future。
（事實上，RunnableFuture 是在 JDK1.6 時添加的類，我猜測在 JDK1.5 時 FutureTask 應該是直接實現的 Runnable 和 Future，而不是通過 RunnableFuture）

Future.java 的源碼：

Future 包含的方法有 5 個，本文只關注它兩個 get 相關的方法。通過 Java 的 API 文檔，我們可以知道 get 方法是用來返回和 Future 關聯的任務的結果（即構造 FutureTask 時使用的 Callable 的結果）。帶參數的 get 方法指定一個超時時間，在超時時間內該方法會阻塞當前線程，直到獲得結果之后停止阻塞繼續運行 —— 如果在給定的超時時間內沒有獲得結果，那么便拋出 TimeoutException 異常；不帶參數的 get 可以理解為超時時間無限大，即一直等待直到獲得結果。

（Future 每個方法的詳細用法可以參考 Java 多線程（3））

通過以上我們可以知道，Callable、Future、FutureTask 這三個類是相輔相成的。以上提到關鍵類的類關系如下：

現在我們看看 FutureTask 中實現 Runnable 的 run 方法是怎樣的（我們直接看關鍵代碼）：

代碼的意思很明確，調用構造 FutureTask 時傳入的 Callable 的 call 方法，如果正常執行完畢，那么通過 set(result) 設置結果，通過 get() 方法得到的即為這個結果 —— 思路和前面第一種方法是一致的（當然 FutureTask 是更強大和更通用的類）；否則即為拋出異常的情況。

使用 FutureTask 的過程如下：
（1）通過一個 Callable 任務或者一個 Runnable（一開始就指定 result）任務構造 FutureTask；
（2）將 FutureTask 交給 Thread 去運行；
（3）使用 FutureTask 的 get 方法（或者 Thread 的 join 方法）阻塞當前線程直到獲得任務的結果。

現在我們使用 Callable 改寫程序：

import java.util.*;
import java.util.concurrent.*;

public class CallableTest {

    public static void main(String[] args) throws Exception {
        System.out.println("使用 Callable 獲得返回結果：");
        
        List> futureTasks = new ArrayList<>(10);
        // 新建 10 個線程，每個線程分別負責累加 1~10, 11~20, ..., 91~100
        for (int i = 0; i < 10; i++) {
            AccumCallable task = new AccumCallable(i * 10 + 1, (i + 1) * 10);
            FutureTask futureTask = new FutureTask<>(task);
            futureTasks.add(futureTask);
            
            Thread worker = new Thread(futureTask, "慢速累加器線程" + i);
            worker.start();
        }

        int total = 0;
        for (FutureTask futureTask : futureTasks) {
            total += futureTask.get(); // get() 方法會阻塞直到獲得結果
        }

        System.out.println("累加的結果: " + total);
    }

    static final class AccumCallable implements Callable {

        private final int begin;
        private final int end;

        public AccumCallable(int begin, int end) {
            this.begin = begin;
            this.end = end;
        }

        @Override
        public Integer call() throws Exception {
            int result = 0;
            for (int i = begin; i <= end; i++) {
                result += i;
                Thread.sleep(100);
            }
            System.out.printf("(%s) - 運行結束，結果為 %d
",
                    Thread.currentThread().getName(), result);

            return result;
        }
     
    }
    
}

運行結果：

可以看到使用 Callable + FutureTask 的程序代碼要比 Runnable 的代碼更簡潔和方便 —— 當需要線程執行完成返回結果時（或者任務需要拋出異常），Callable 是優先于 Runnable 的選擇。