Java併發程式設計:Callable、Future和FutureTask
這2種方式都有一個缺陷就是:在執行完任務之後無法獲取執行結果。
如果需要獲取執行結果,就必須通過共享變數或者使用執行緒通訊的方式來達到效果,這樣使用起來就比較麻煩。
而自從Java 1.5開始,就提供了Callable和Future,通過它們可以在任務執行完畢之後得到任務執行結果。
今天我們就來討論一下Callable、Future和FutureTask三個類的使用方法。以下是本文的目錄大綱:
一.Callable與Runnable
二.Future
三.FutureTask
四.使用示例
若有不正之處請多多諒解,並歡迎批評指正。
請尊重作者勞動成果,轉載請標明原文連結:
http://www.cnblogs.com/dolphin0520/p/3949310.html
一.Callable與Runnable
先說一下java.lang.Runnable吧,它是一個介面,在它裡面只宣告瞭一個run()方法:
1
2
3
|
public
interface Runnable { public
abstract void
run(); } |
由於run()方法返回值為void型別,所以在執行完任務之後無法返回任何結果。
Callable位於java.util.concurrent包下,它也是一個介面,在它裡面也只宣告瞭一個方法,只不過這個方法叫做call():
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; } |
可以看到,這是一個泛型介面,call()函式返回的型別就是傳遞進來的V型別。
那麼怎麼使用Callable呢?一般情況下是配合ExecutorService來使用的,在ExecutorService介面中宣告瞭若干個submit方法的過載版本:
1
2
3
|
<T> Future<T> submit(Callable<T> task); <T> Future<T> submit(Runnable task, T result); Future<?> submit(Runnable task); |
第一個submit方法裡面的引數型別就是Callable。
暫時只需要知道Callable一般是和ExecutorService配合來使用的,具體的使用方法講在後面講述。
一般情況下我們使用第一個submit方法和第三個submit方法,第二個submit方法很少使用。
二.Future
Future就是對於具體的Runnable或者Callable任務的執行結果進行取消、查詢是否完成、獲取結果。必要時可以通過get方法獲取執行結果,該方法會阻塞直到任務返回結果。
Future類位於java.util.concurrent包下,它是一個介面:
1
2
3
4
5
6
7
8
|
public
interface Future<V> { boolean
cancel( boolean
mayInterruptIfRunning); boolean
isCancelled(); boolean
isDone(); V get()
throws InterruptedException, ExecutionException; V get( long
timeout, TimeUnit unit) throws
InterruptedException, ExecutionException, TimeoutException; } |
在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)能夠獲取任務執行結果。
因為Future只是一個介面,所以是無法直接用來建立物件使用的,因此就有了下面的FutureTask。
三.FutureTask
我們先來看一下FutureTask的實現:
1
|
public
class FutureTask<V> implements
RunnableFuture<V> |
FutureTask類實現了RunnableFuture介面,我們看一下RunnableFuture介面的實現:
1
2
3
|
public
interface RunnableFuture<V> extends
Runnable, Future<V> { void
run(); } |
可以看出RunnableFuture繼承了Runnable介面和Future介面,而FutureTask實現了RunnableFuture介面。所以它既可以作為Runnable被執行緒執行,又可以作為Future得到Callable的返回值。
FutureTask提供了2個構造器:
1
2
3
4
|
public
FutureTask(Callable<V> callable) { } public
FutureTask(Runnable runnable, V result) { } |
事實上,FutureTask是Future介面的一個唯一實現類。
四.使用示例
1.使用Callable+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
|
public
class Test { public
static void
main(String[] args) { ExecutorService executor = Executors.newCachedThreadPool(); Task task =
new Task(); Future<Integer> result = executor.submit(task); executor.shutdown(); try
{ Thread.sleep( 1000 ); }
catch (InterruptedException e1) { e1.printStackTrace(); } System.out.println( "主執行緒在執行任務" ); try
{ System.out.println( "task執行結果" +result.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; } } |
執行結果:
子執行緒在進行計算
主執行緒在執行任務
task執行結果4950
所有任務執行完畢
2.使用Callable+FutureTask獲取執行結果
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
|
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; } } |
如果為了可取消性而使用 Future 但又不提供可用的結果,則可以宣告 Future<?> 形式型別、並返回 null 作為底層任務的結果。
執行緒池設定4個執行緒,並行處理5個任務。程式碼如下:
public class TestCallback {
public static void main(String args[]) {
ExecutorService executor = Executors.newFixedThreadPool(4);
Task task = new Task();
// FutureTask<Integer> result = new FutureTask<>(task);
// Future<Integer> result = executor.submit(task);
for (int i = 0; i < 5; ++i) {
// new Thread(result).start();
FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
executor.submit(futureTask);
}
executor.shutdown();
}
}
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;
}
}
相關文章
- Java併發程式設計非同步操作Future和FutureTaskJava程式設計非同步
- Java多執行緒——Callable、Future和FutureTaskJava執行緒
- Java併發之Executor + Callable + FutureJava
- Java多執行緒之Callable,Future,FutureTaskJava執行緒
- Java併發程式設計實戰--FutureTaskJava程式設計
- 搞懂Runnable Callable Future FutureTask 及應用
- Java併發程式設計-Future系列之Future的介紹和基本用法Java程式設計
- Runnable、Callable、Executor、Future、FutureTask關係解讀
- 大話Android多執行緒(四) Callable、Future和FutureTaskAndroid執行緒
- 併發程式設計—— FutureTask 原始碼分析程式設計原始碼
- 在Java中使用Callable和FutureJava
- Java多執行緒-Callable和FutureJava執行緒
- Java多執行緒21:多執行緒下的其他元件之CyclicBarrier、Callable、Future和FutureTaskJava執行緒元件
- 執行緒執行 之 Runnable Callable Future ,FutureTask ExcutorService概覽執行緒
- 【併發程式設計】Future模式新增Callback及Promise 模式程式設計模式Promise
- java 併發程式設計Java程式設計
- Java併發程式設計Java程式設計
- 【併發程式設計】Future模式及JDK中的實現程式設計模式JDK
- Java併發程式設計——synchronize 和 ReentrantLockJava程式設計ReentrantLock
- Java併發程式設計:CountDownLatch、CyclicBarrier和SemaphoreJava程式設計CountDownLatch
- 《java併發程式設計的藝術》併發容器和框架Java程式設計框架
- 【Java併發程式設計】併發程式設計大合集-值得收藏Java程式設計
- JUC併發程式設計學習筆記(六)Callable(簡單)程式設計筆記
- Java併發程式設計 - 第十一章 Java併發程式設計實踐Java程式設計
- C++11併發程式設計:async,future,packaged_task,promiseC++程式設計PackagePromise
- java-併發程式設計Java程式設計
- Java併發程式設計-CASJava程式設計
- Java併發程式設計:synchronizedJava程式設計synchronized
- Java 併發程式設計解析Java程式設計
- Java併發程式設計:LockJava程式設計
- Java併發程式設計---java規範與模式下的併發程式設計1.1Java程式設計模式
- Java併發程式設計-鎖及併發容器Java程式設計
- Java併發系列—併發程式設計挑戰Java程式設計
- java併發程式設計系列:java併發程式設計背景知識Java程式設計
- 說一說併發設計模式—Future(非同步)設計模式非同步
- 併發程式設計和並行程式設計程式設計並行行程
- Java併發程式設計藝術Java程式設計
- Java併發程式設計實踐Java程式設計