Java中存在Runnable、Callable、Future、FutureTask這幾個與執行緒相關的類或者介面，在Java中也是比較重要的幾個概念，我們通過下面的簡單示例來了解一下它們的作用於區別。

Runnable

其中Runnable應該是我們最熟悉的介面，它只有一個run()函式，用於將耗時操作寫在其中，該函式沒有返回值。然後使用某個執行緒去執行該runnable即可實現多執行緒，Thread類在呼叫start()函式後就是執行的是Runnable的run()函式。Runnable的宣告如下 : 

1. publicinterface Runnable {  
2.     /** 
3.      * When an object implementing interface <code>Runnable</code> is used
    
4.      * to create a thread, starting the thread causes the object's 
5.      * <code>run</code> method to be called in that separately executing 
6.      * thread. 
7.      * <p> 
8.      * 
9.      * @see     java.lang.Thread#run() 
10.      */
11.     publicabstractvoid run();  
12. }  

Callable

Callable與Runnable的功能大致相似，Callable中有一個call()函式，但是call()函式有返回值

，而Runnable的run()函式不能將結果返回給客戶程式。Callable的宣告如下 :

1. publicinterface Callable<V> {  
2.     /** 
3.      * Computes a result, or throws an exception if unable to do so. 
4.      * 
5.      * @return computed result 
6.      * @throws Exception if unable to compute a result 
7.      */
8.     V call() throws Exception;  
9. }  

可以看到，這是一個泛型介面，call()函式返回的型別就是客戶程式傳遞進來的V型別。

Future

Executor就是Runnable和Callable的排程容器，Future就是對於具體的Runnable或者Callable任務的執行結果進行

取消、查詢是否完成、獲取結果、設定結果操作。get方法會阻塞，直到任務返回結果(Future簡介)。Future宣告如下 :

1. /** 
2. * @see FutureTask 
3.  * @see Executor 
4.  * @since 1.5 
5.  * @author Doug Lea 
6.  * @param <V> The result type returned by this Future's <tt>get</tt> method 
7.  */
8. publicinterface Future<V> {  
9.     /** 
10.      * Attempts to cancel execution of this task.  This attempt will 
11.      * fail if the task has already completed, has already been cancelled, 
12.      * or could not be cancelled for some other reason. If successful, 
13.      * and this task has not started when <tt>cancel</tt> is called, 
14.      * this task should never run.  If the task has already started, 
15.      * then the <tt>mayInterruptIfRunning</tt> parameter determines 
16.      * whether the thread executing this task should be interrupted in 
17.      * an attempt to stop the task.     * 
18.      */
19.     boolean cancel(boolean mayInterruptIfRunning);  
20.     /** 
21.      * Returns <tt>true</tt> if this task was cancelled before it completed 
22.      * normally. 
23.      */
24.     boolean isCancelled();  
25.     /** 
26.      * Returns <tt>true</tt> if this task completed. 
27.      * 
28.      */
29.     boolean isDone();  
30.     /** 
31.      * Waits if necessary for the computation to complete, and then 
32.      * retrieves its result. 
33.      * 
34.      * @return the computed result 
35.      */
36.     V get() throws InterruptedException, ExecutionException;  
37.     /** 
38.      * Waits if necessary for at most the given time for the computation 
39.      * to complete, and then retrieves its result, if available. 
40.      * 
41.      * @param timeout the maximum time to wait 
42.      * @param unit the time unit of the timeout argument 
43.      * @return the computed result 
44.      */
45.     V get(long timeout, TimeUnit unit)  
46.         throws InterruptedException, ExecutionException, TimeoutException;  
47. }  

FutureTask

FutureTask則是一個RunnableFuture<V>，而RunnableFuture實現了Runnbale又實現了Futrue<V>這兩個介面，

1. publicclass FutureTask<V> implements RunnableFuture<V>  

RunnableFuture

1. publicinterface RunnableFuture<V> extends Runnable, Future<V> {  
2.     /** 
3.      * Sets this Future to the result of its computation 
4.      * unless it has been cancelled. 
5.      */
6.     void run();  
7. }  

另外它還可以包裝Runnable和Callable<V>， 由建構函式注入依賴。

1. public FutureTask(Callable<V> callable) {  
2.     if (callable == null)  
3.         thrownew NullPointerException();  
4.     this.callable = callable;  
5.     this.state = NEW;       // ensure visibility of callable
6. }  
7. public FutureTask(Runnable runnable, V result) {  
8.     this.callable = Executors.callable(runnable, result);  
9.     this.state = NEW;       // ensure visibility of callable
10. }  

可以看到，Runnable注入會被Executors.callable()函式轉換為Callable型別，即FutureTask最終都是執行Callable型別的任務。該適配函式的實現如下 ：

1. publicstatic <T> Callable<T> callable(Runnable task, T result) {  
2.     if (task == null)  
3.         thrownew NullPointerException();  
4.     returnnew RunnableAdapter<T>(task, result);  
5. }  

RunnableAdapter介面卡

1. /** 
2.  * A callable that runs given task and returns given result 
3.  */
4. staticfinalclass RunnableAdapter<T> implements Callable<T> {  
5.     final Runnable task;  
6.     final T result;  
7.     RunnableAdapter(Runnable task, T result) {  
8.         this.task = task;  
9.         this.result = result;  
10.     }  
11.     public T call() {  
12.         task.run();  
13.         return result;  
14.     }  
15. }  

由於FutureTask實現了Runnable，因此它既可以通過Thread包裝來直接執行，也可以提交給ExecuteService來執行。

並且還可以直接通過get()函式獲取執行結果，該函式會阻塞，直到結果返回。因此FutureTask既是Future、

Runnable，又是包裝了Callable( 如果是Runnable最終也會被轉換為Callable )， 它是這兩者的合體。

簡單示例

1. package com.effective.java.concurrent.task;  
2. import java.util.concurrent.Callable;  
3. import java.util.concurrent.ExecutionException;  
4. import java.util.concurrent.ExecutorService;  
5. import java.util.concurrent.Executors;  
6. import java.util.concurrent.Future;  
7. import java.util.concurrent.FutureTask;  
8. /** 
9.  *  
10.  * @author mrsimple 
11.  * 
12.  */
13. publicclass RunnableFutureTask {  
14.     /** 
15.      * ExecutorService 
16.      */
17.     static ExecutorService mExecutor = Executors.newSingleThreadExecutor();  
18.     /** 
19.      *  
20.      * @param args 
21.      */
22.     publicstaticvoid main(String[] args) {  
23.         runnableDemo();  
24.         futureDemo();  
25.     }  
26.     /** 
27.      * runnable, 無返回值 
28.      */
29.     staticvoid runnableDemo() {  
30.         new Thread(new Runnable() {  
31.             @Override
32.             publicvoid run() {  
33.                 System.out.println("runnable demo : " + fibc(20));  
34.             }  
35.         }).start();  
36.     }  
37.     /** 
38.      * 其中Runnable實現的是void run()方法，無返回值；Callable實現的是 V 
39.      * call()方法，並且可以返回執行結果。其中Runnable可以提交給Thread來包裝下 
40.      * ，直接啟動一個執行緒來執行，而Callable則一般都是提交給ExecuteService來執行。 
41.      */
42.     staticvoid futureDemo() {  
43.         try {  
44.             /** 
45.              * 提交runnable則沒有返回值, future沒有資料 
46.              */
47.             Future<?> result = mExecutor.submit(new Runnable() {  
48.                 @Override
49.                 publicvoid run() {  
50.                     fibc(20);  
51.                 }  
52.             });  
53.             System.out.println("future result from runnable : " + result.get());  
54.             /** 
55.              * 提交Callable, 有返回值, future中能夠獲取返回值 
56.              */
57.             Future<Integer> result2 = mExecutor.submit(new Callable<Integer>() {  
58.                 @Override
59.                 public Integer call() throws Exception {  
60.                     return fibc(20);  
61.                 }  
62.             });  
63.             System.out  
64.                     .println("future result from callable : " + result2.get());  
65.             /** 
66.              * FutureTask則是一個RunnableFuture<V>，即實現了Runnbale又實現了Futrue<V>這兩個介面， 
67.              * 另外它還可以包裝Runnable(實際上會轉換為Callable)和Callable 
68.              * <V>，所以一般來講是一個符合體了，它可以通過Thread包裝來直接執行，也可以提交給ExecuteService來執行 
69.              * ，並且還可以通過v get()返回執行結果，線上程體沒有執行完成的時候，主執行緒一直阻塞等待，執行完則直接返回結果。 
70.              */
71.             FutureTask<Integer> futureTask = new FutureTask<Integer>(  
72.                     new Callable<Integer>() {  
73.                         @Override
74.                         public Integer call() throws Exception {  
75.                             return fibc(20);  
76.                         }  
77.                     });  
78.             // 提交futureTask
79.             mExecutor.submit(futureTask) ;  
80.             System.out.println("future result from futureTask : "
81.                     + futureTask.get());  
82.         } catch (InterruptedException e) {  
83.             e.printStackTrace();  
84.         } catch (ExecutionException e) {  
85.             e.printStackTrace();  
86.         }  
87.     }  
88.     /** 
89.      * 效率底下的斐波那契數列, 耗時的操作 
90.      *  
91.      * @param num 
92.      * @return 
93.      */
94.     staticint fibc(int num) {  
95.         if (num == 0) {  
96.             return0;  
97.         }  
98.         if (num == 1) {  
99.             return1;  
100.         }  
101.         return fibc(num - 1) + fibc(num - 2);  
102.     }  
103. }  

輸出結果

頂

3

踩

0