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

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

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

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

{ 題外話開始：

通過 Thread 的類聲明：

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

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

題外話結(jié)束 }

Runnable.java 的代碼：

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

第一種方法：在 Runnable 的實現(xiàn)類中設置一個變量 V，在 run 方法中將其改變?yōu)槲覀兤诖慕Y(jié)果，然后通過一個 getV() 方法將這個變量返回。

import java.util.*;

public class RunnableTest {

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

        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();  // 等待線程執(zhí)行完畢
            total += tasks.get(i).getResult();
        }

        System.out.println("
累加的結(jié)果: " + 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) - 運行結(jié)束，結(jié)果為 %d
",
                    Thread.currentThread().getName(), result);
        }

        public int getResult() {
            return result;
        }
    }

}

運行結(jié)果：

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

Callable.java 的代碼：

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

但是查看 Thread 的構(gòu)造方法，我們發(fā)現(xiàn) Thread 只提供了將 Runnable 作為參數(shù)的構(gòu)造方法，并沒有使用 Callable 的構(gòu)造方法 —— 所以引出 FutureTask。

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

可以看到它實現(xiàn)了 RunnableFuture 這個接口，我們再看看 RunnableFuture：

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

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

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

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

Future.java 的源碼：

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

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

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

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

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

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

現(xiàn)在我們使用 Callable 改寫程序：

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

public class CallableTest {

    public static void main(String[] args) throws Exception {
        System.out.println("使用 Callable 獲得返回結(jié)果：");
        
        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() 方法會阻塞直到獲得結(jié)果
        }

        System.out.println("累加的結(jié)果: " + 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) - 運行結(jié)束，結(jié)果為 %d
",
                    Thread.currentThread().getName(), result);

            return result;
        }
     
    }
    
}

運行結(jié)果：

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