Callable、Future和FutureTask，callablefuturetask

Callable、Future和FutureTask，callablefuturetask

建立線程的2種方式，一種是直接繼承Thread，另外一種就是實現Runnable介面。這2種方式都有一個缺陷就是：在執行完任務之後無法擷取執行結果。

如果需要擷取執行結果，就必須通過共用變數或者使用線程通訊的方式來達到效果，這樣使用起來就比較麻煩。而自從Java 1.5開始，就提供了Callable和Future，通過它們可以在任務執行完畢之後得到任務執行結果。

• callable和runnable

　　java.lang.Runnable吧，它是一個介面，在它裡面只聲明了一個run()方法：

1 public interface Runnable {2     public abstract void run();3 }

　　由於run()方法傳回值為void類型，所以在執行完任務之後無法返回任何結果。

　　Callable位於java.util.concurrent包下，它也是一個介面，在它裡面也只聲明了一個方法，只不過這個方法叫做call()：　

1 public interface Callable<V> {2     V call() throws Exception;3 }

　　可以看到，這是一個泛型介面，call()函數返回的類型就是傳遞進來的V類型。

　　Callable一般情況下是配合ExecutorService來使用的，在ExecutorService介面中聲明了若干個submit方法的重載版本：

1 <T> Future<T> submit(Callable<T> task);2 <T> Future<T> submit(Runnable task, T result);3 Future<?> submit(Runnable task);

　　總之，Callable 介面類似於 Runnable，兩者都是為那些其執行個體可能被另一個線程執行的類設計的。但是 Runnable 不會返回結果，並且無法拋出經過檢查的異常。

• Future

　　Future 表示非同步計算的結果。它提供了檢查計算是否完成的方法，以等待計算的完成，並擷取計算的結果。計算完成後只能使用 get 方法來擷取結果，如有必要，計算完成前可以阻塞此方法。取消則由 cancel 方法來執行。還提供了其他方法，以確定任務是正常完成還是被取消了。一旦計算完成，就不能再取消計算。如果為了可取消性而使用 Future 但又不提供可用的結果，則可以聲明 Future<?> 形式類型、並返回 null 作為底層任務的結果。

　　Future類位於java.util.concurrent包下，它是一個介面：

1 public interface Future<V> {2     boolean cancel(boolean mayInterruptIfRunning);3     boolean isCancelled();4     boolean isDone();5     V get() throws InterruptedException, ExecutionException;6     V get(long timeout, TimeUnit unit)throws InterruptedException, ExecutionException, TimeoutException;7 }

　　在Future介面中聲明了5個方法，下面依次解釋每個方法的作用：

• cancel方法用來取消任務，如果取消任務成功則返回true，如果取消任務失敗則返回false。參數mayInterruptIfRunning表示是否允許取消正在執行卻沒有執行完畢的任務，如果設定true，則表示可以取消正在執行過程中的任務。如果任務已經完成，則無論mayInterruptIfRunning為true還是false，此方法肯定返回false，即如果取消已經完成的任務會返回false；如果任務正在執行，若mayInterruptIfRunning設定為true，則返回true，若mayInterruptIfRunning設定為false，則返回false；如果任務還沒有執行，則無論mayInterruptIfRunning為true還是false，肯定返回true。
• isCancelled方法表示任務是否被取消成功，如果在任務正常完成前被取消成功，則返回 true。
• isDone方法表示任務是否已經完成，若任務完成，則返回true；
• get()方法用來擷取執行結果，這個方法會產生阻塞，會一直等到任務執行完畢才返回；
• get(long timeout, TimeUnit unit)用來擷取執行結果，如果在指定時間內，還沒擷取到結果，就直接返回null。

　　也就是說Future提供了三種功能：

　　1）判斷任務是否完成；

　　2）能夠中斷任務；

　　3）能夠擷取任務執行結果。

• FutureTask

　　FutureTask的實現

1 public class FutureTask<V> implements RunnableFuture<V>

　　RunnableFuture介面的實現：

1 public interface RunnableFuture<V> extends Runnable, Future<V> {2     void run();3 }

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

　　可取消的非同步計算。利用開始和取消計算的方法、查詢計算是否完成的方法和擷取計算結果的方法，此類提供了對 Future 的基本實現。僅在計算完成時才能擷取結果；如果計算尚未完成，則阻塞 get 方法。一旦計算完成，就不能再重新開始或取消計算。

　　可使用 FutureTask 封裝 Callable 或 Runnable 對象。因為 FutureTask 實現了 Runnable，所以可將 FutureTask 提交給 Executor 執行。  

• 執行個體

使用future擷取輸出結果：

 1 ExecutorService threadPool = Executors.newSingleThreadExecutor(); 2          3         Future<String> future = threadPool.submit(new Callable<String>() { 4             @Override 5             public String call() throws Exception { 6                 Thread.sleep(2000); 7                 return "hello"; 8             } 9         });10         System.out.println("準備計算結果");11         12         try {13             System.out.println("擷取結果："+future.get());14         } catch (InterruptedException e) {15             e.printStackTrace();16         } catch (ExecutionException e) {17             e.printStackTrace();18         }

使用CompletionService提交一組callable任務，使用take()擷取已經完成的callable任務對應的future對象。

 1 ExecutorService threadPool = Executors.newFixedThreadPool(10); 2          3         CompletionService<Integer> completionService = new ExecutorCompletionService<>(threadPool); 4          5         for (int i = 0; i < 10; i++) { 6             final int seq = i; 7             completionService.submit(new Callable<Integer>() { 8                 @Override 9                 public Integer call() throws Exception {10                     Thread.sleep(new Random().nextInt(5000));11                     return seq;12                 }13             });14         }15         for (int i = 0; i < 10; i++) {16             try {17                 System.out.println(completionService.take().get());18             } catch (InterruptedException e) {19                 // TODO Auto-generated catch block20                 e.printStackTrace();21             } catch (ExecutionException e) {22                 // TODO Auto-generated catch block23                 e.printStackTrace();24             }25         }

使用Callable+Future擷取執行結果

 1 public class Test { 2     public static void main(String[] args) { 3         ExecutorService executor = Executors.newCachedThreadPool(); 4         Task task = new Task(); 5         Future<Integer> result = executor.submit(task); 6         executor.shutdown(); 7           8         try { 9             Thread.sleep(1000);10         } catch (InterruptedException e1) {11             e1.printStackTrace();12         }13          14         System.out.println("主線程在執行任務");15          16         try {17             System.out.println("task運行結果"+result.get());18         } catch (InterruptedException e) {19             e.printStackTrace();20         } catch (ExecutionException e) {21             e.printStackTrace();22         }23          24         System.out.println("所有任務執行完畢");25     }26 }27 class Task implements Callable<Integer>{28     @Override29     public Integer call() throws Exception {30         System.out.println("子線程在進行計算");31         Thread.sleep(3000);32         int sum = 0;33         for(int i=0;i<100;i++)34             sum += i;35         return sum;36     }37 }

使用Callable+FutureTask擷取執行結果

public class Test {    public static void main(String[] args) {        //第一種方式        ExecutorService executor = Executors.newCachedThreadPool();        Task task = new Task();        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);        executor.submit(futureTask);        executor.shutdown();                 //第二種方式，注意這種方式和第一種方式效果是類似的，只不過一個使用的是ExecutorService，一個使用的是Thread        /*Task task = new Task();        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);        Thread thread = new Thread(futureTask);        thread.start();*/                 try {            Thread.sleep(1000);        } catch (InterruptedException e1) {            e1.printStackTrace();        }                 System.out.println("主線程在執行任務");                 try {            System.out.println("task運行結果"+futureTask.get());        } catch (InterruptedException e) {            e.printStackTrace();        } catch (ExecutionException e) {            e.printStackTrace();        }                 System.out.println("所有任務執行完畢");    }}class Task implements Callable<Integer>{    @Override    public Integer call() throws Exception {        System.out.println("子線程在進行計算");        Thread.sleep(3000);        int sum = 0;        for(int i=0;i<100;i++)            sum += i;        return sum;    }}

參考部落格：http://www.cnblogs.com/dolphin0520/p/3949310.html

API