Java中的Runnable、Callable、Future、FutureTask的區別與示例


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

Runnable

其中Runnable應該是我們最熟悉的接口,它只有一個run()函數,用於將耗時操作寫在其中,該函數沒有返回值。然后使用某個線程去執行該runnable即可實現多線程,Thread類在調用start()函數后就是執行的是Runnable的run()函數。Runnable的聲明如下 :

 

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

 

Callable

 

Callable與Runnable的功能大致相似,Callable中有一個call()函數,但是call()函數有返回值,而Runnable的run()函數不能將結果返回給客戶程序。Callable的聲明如下 :

 

?
1
2
3
4
5
6
7
8
9
public interface Callable<v> {
     /**
      * Computes a result, or throws an exception if unable to do so.
      *
      * @return computed result
      * @throws Exception if unable to compute a result
      */
     V call() throws Exception;
}</v>
可以看到,這是一個泛型接口,call()函數返回的類型就是客戶程序傳遞進來的V類型。

 

 

Future

Executor就是Runnable和Callable的調度容器,Future就是對於具體的Runnable或者Callable任務的執行結果進行

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

 

 

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

 

FutureTask

FutureTask則是一個RunnableFuture,而RunnableFuture實現了Runnbale又實現了Futrue這兩個接口,

 

?
1
public class FutureTask<v> implements RunnableFuture<v></v></v>
RunnableFuture

 

 

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

 

另外它還可以包裝Runnable和Callable, 由構造函數注入依賴。

 

?
1
2
3
4
5
6
7
8
9
10
11
public FutureTask(Callable<v> callable) {
     if (callable == null )
         throw new NullPointerException();
     this .callable = callable;
     this .state = NEW;       // ensure visibility of callable
}
 
public FutureTask(Runnable runnable, V result) {
     this .callable = Executors.callable(runnable, result);
     this .state = NEW;       // ensure visibility of callable
}</v>
可以看到,Runnable注入會被Executors.callable()函數轉換為Callable類型,即FutureTask最終都是執行Callable類型的任務。該適配函數的實現如下 :

 

 

?
1
2
3
4
5
public static <t> Callable<t> callable(Runnable task, T result) {
     if (task == null )
         throw new NullPointerException();
     return new RunnableAdapter<t>(task, result);
}</t></t></t>
RunnableAdapter適配器

 

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

 

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

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

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

 

簡單示例

 

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

 

輸出結果


 

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM