在上一章節我們介紹了Java實現多執行緒最常用的兩種方式，但是那兩種方式實現執行緒的時候並不能返回執行緒的執行結果。然而有些場景我們需要得到執行緒的執行結果，比如要計算每個部門的這個月的工資，然後進行總計（假設有n個部門，計算每個部門的工資需要花費m個小時，計算總計需要k個小時）。那麼有以下兩種方案供選擇“：

1. n個部門工資計算和總計都安排給一個人來做，需要花費n*m+k小時；
2. 每個部門工資計算都分別安排給一個人來做（同時進行），最後一個人做統計工作，那麼需要花費m+k小時即可；

方案一採用順序執行的方式來做，需要花費的時間比較長；方案二採用執行並行的方式來做，在短時間內會花費更多的資源，但是節省了時間。方案一比較簡單，在這裡就不多贅述。讓我們看下如何使用多執行緒的方式來實現方案二。

方案二的實現其實也很簡單，無法是在多執行緒的基礎上加上執行緒執行結果返回，Java中提供了Callable、Future和FutrueTask相關工具來協助我們實現，接下來就看下是如何實現的吧！

• Callable+Future實現：

//首先實現一個計算工資的Task類 並實現Callable介面 （執行緒返回結果型別即泛型填充型別）
 public class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("部門："
 
+ Thread.currentThread().getId()+"正在計算工資");
        Random random = new Random();
        Thread.sleep(2000);//模擬工資計算耗時
        Integer sum = random.nextInt(100000);
        System.out.println("部門："+ Thread.currentThread().getId()+"計算完成。結果："+sum);
        return sum;
    }
}

//執行任務計算Main
public class Main {

    public
 
 static void main(String []args){
        //建立固定的執行緒數的執行緒池，不瞭解執行緒池的可以去了解下
        ExecutorService pool = Executors.newFixedThreadPool(5);

        Task task1 = new Task();
        Task task2 = new Task();
        Task task3 = new Task();
        Task task4 = new Task();
        Task task5 = new Task();

        long protime = System.currentTimeMillis();
        //將五個部門的工資計算交由執行緒池中的執行緒執行
        Future<Integer> result1 = pool.submit(task1);
        Future<Integer> result2 = pool.submit(task2);
        Future<Integer> result3 = pool.submit(task3);
        Future<Integer> result4 = pool.submit(task4);
        Future<Integer> result5 = pool.submit(task5);

        Integer sum = 0;
        //獲取根據submit提交返回的型別為Future<Integer>型別的result獲取執行緒執行結果（執行緒任務沒執行完的話，在呼叫get方法的時會wait等待結果執行完成）
        try {
            sum += result1.get();
            sum += result2.get();
            sum += result3.get();
            sum += result4.get();
            sum += result5.get();
        } catch (InterruptedException e){       
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        long time = System.currentTimeMillis()-protime;
        System.out.println("總計需發工資："+sum+" 耗時："+time);
    }
}

• Callable+FutureTask實現：

//首先實現一個計算工資的Task類 並實現Callable介面 （執行緒返回結果型別即泛型填充型別）
 public class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("部門："+ Thread.currentThread().getId()+"正在計算工資");
        Random random = new Random();
        Thread.sleep(2000);//模擬工資計算耗時
        Integer sum = random.nextInt(100000);
        System.out.println("部門："+ Thread.currentThread().getId()+"計算完成。結果："+sum);
        return sum;
    }
}

public class Main {
    public static void main(String []args){
        ExecutorService pool = Executors.newFixedThreadPool(5);

        /**
        FutureTask實現了RunnableFuture介面， RunnableFuture介面實現Runnable和Future介面
        FutureTask相當於執行緒和結果的結合
        */
        FutureTask<Integer> futureTask1 = new FutureTask<>(new Task());
        FutureTask<Integer> futureTask2 = new FutureTask<>(new Task());
        FutureTask<Integer> futureTask3 = new FutureTask<>(new Task());
        FutureTask<Integer> futureTask4 = new FutureTask<>(new Task());
        FutureTask<Integer> futureTask5 = new FutureTask<>(new Task());

        long protime = System.currentTimeMillis();
        pool.submit(futureTask1);
        pool.submit(futureTask2);
        pool.submit(futureTask3);
        pool.submit(futureTask4);
        pool.submit(futureTask5);
        pool.shutdown();

        Integer sum = 0;
        try {
            sum += futureTask1.get();
            sum += futureTask2.get();
            sum += futureTask3.get();
            sum += futureTask4.get();
            sum += futureTask5.get();
        } catch (InterruptedException e){       
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        long time = System.currentTimeMillis()-protime;
        System.out.println("總計需發工資："+sum+" 耗時："+time);
    }
}

兩種方式實現的執行效果基本一樣（排除隨機等因素）：

由結果分析，5個執行緒同時執行，大概計算2s後，相繼計算出結果結果，耗時大概2s。

總結：
future模式在Java多執行緒的用處還是蠻大的，尤其是在做平行計算的場景下。Java為我們提供了相關工具，所以實現難度也不大，加以練習就會很容易掌握。但是為了深刻理解future模式以及實現原理，下一章節會來手動實現future模式，敬請期待！！！（文章中如有描述不明確或不正確的地方，歡迎大家批評指正，謝謝）。