Java多線程之Callable和Future

本篇說明的是Callable和Future，它倆頗有意思的，一個產生結果，一個拿到結果。 

Callable接口相似於Runnable，從名字就能夠看出來了，可是Runnable不會返回結果，而且沒法拋出返回結果的異常，而Callable功能更強大一些，被線程執行後，能夠返回值，這個返回值能夠被Future拿到，也就是說，Future能夠拿到異步執行任務的返回值，下面來看一個簡單的例子：

public class CallableAndFuture {
    public static void main(String[] args) {
        Callable<Integer> callable = new Callable<Integer>() {
            public Integer call() throws Exception {
                return new Random().nextInt(100);
            }
        };
        FutureTask<Integer> future = new FutureTask<Integer>(callable);
        new Thread(future).start();
        try {
            Thread.sleep(5000);// 可能作一些事情
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

FutureTask實現了兩個接口，Runnable和Future，因此它既能夠做爲Runnable被線程執行，又能夠做爲Future獲得Callable的返回值，那麼這個組合的使用有什麼好處呢？假設有一個很耗時的返回值須要計算，而且這個返回值不是馬上須要的話，那麼就可使用這個組合，用另外一個線程去計算返回值，而當前線程在使用這個返回值以前能夠作其它的操做，等到須要這個返回值時，再經過Future獲得，豈不美哉！這裏有一個Future模式的介紹：http://openhome.cc/Gossip/DesignPattern/FuturePattern.htm。 

下面來看另外一種方式使用Callable和Future，經過ExecutorService的submit方法執行Callable，並返回Future，代碼以下：

public class CallableAndFuture {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        Future<Integer> future = threadPool.submit(new Callable<Integer>() {
            public Integer call() throws Exception {
                return new Random().nextInt(100);
            }
        });
        try {
            Thread.sleep(5000);// 可能作一些事情
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

代碼是否是簡化了不少，ExecutorService繼承自Executor，它的目的是爲咱們管理Thread對象，從而簡化併發編程，Executor使咱們無需顯示的去管理線程的生命週期，是JDK 5以後啓動任務的首選方式。 

執行多個帶返回值的任務，並取得多個返回值，代碼以下：

public class CallableAndFuture {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newCachedThreadPool();
        CompletionService<Integer> cs = new ExecutorCompletionService<Integer>(threadPool);
        for(int i = 1; i < 5; i++) {
            final int taskID = i;
            cs.submit(new Callable<Integer>() {
                public Integer call() throws Exception {
                    return taskID;
                }
            });
        }
        // 可能作一些事情
        for(int i = 1; i < 5; i++) {
            try {
                System.out.println(cs.take().get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}

其實也能夠不使用CompletionService，能夠先建立一個裝Future類型的集合，用Executor提交的任務返回值添加到集合中，最後遍歷集合取出數據，代碼略。

這裏再闡述一下：提交到CompletionService中的Future是按照完成的順序排列的，這種作法中Future是按照添加的順序排列的。

因此這兩種方式的區別在於：

1. CompletionService.take 會獲取並清除已經完成Task的結果，若是當前沒有已經完成Task時，會阻塞。

2. 「先建立一個裝Future類型的集合，用Executor提交的任務返回值添加到集合中，最後遍歷集合取出數據」——這種方法一般是按照Future加入的順序。

兩個方法最大的差異在於遍歷 Future 的順序，相對來講， CompletionService 的性能更高。考慮以下場景：多線程下載，結果用Future返回。第一個文件特別大，後面的文件很小。用方法1，能很快知道已經下載完文件的結果(不是第一個)；而用方法2，必須等第一個文件下載結束後，纔會得到其餘文件的下載結果。