1.直接看代碼中的demo:
package com.landon.mavs.example.concurrent;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
/** *//**
*
* 使用guava實現異步回調 {@link java.util.concurrent.Future}
* {@link com.google.common.util.concurrent.ListenableFuture}
* {@link com.google.common.util.concurrent.FutureCallback}
*
* @author landon
*
*/
public class FutureCallbackExample 
{
public static void main(String[] args) throws Exception {
// 原生的Future模式,實現異步
ExecutorService nativeExecutor = Executors.newSingleThreadExecutor();
Future<String> nativeFuture = nativeExecutor
.submit(new Callable<String>() {
@Override
public String call() throws Exception {
// 使用sleep模擬調用耗時
TimeUnit.SECONDS.sleep(1);
return "This is native future call.not support async callback";
}
});
// Future只實現了異步，而沒有實現回調.所以此時主線程get結果時阻塞.或者可以輪訓以便獲取異步調用是否完成
System.out.println(nativeFuture.get());
// 好的實現應該是提供回調,即異步調用完成后,可以直接回調.本例采用guava提供的異步回調接口,方便很多.
ListeningExecutorService guavaExecutor = MoreExecutors
.listeningDecorator(Executors.newSingleThreadExecutor());
final ListenableFuture<String> listenableFuture = guavaExecutor
.submit(new Callable<String>() {
@Override
public String call() throws Exception {
Thread.sleep(1000);
return "this is guava future call.support async callback";
}
});
// 注冊監聽器,即異步調用完成時會在指定的線程池中執行注冊的監聽器
listenableFuture.addListener(new Runnable() {
@Override
public void run() {
try {
System.out.println("async complete.result:"
+ listenableFuture.get());
} catch (Exception e) {
}
}
}, Executors.newSingleThreadExecutor());
// 主線程可以繼續執行,異步完成后會執行注冊的監聽器任務.
System.out.println("go on execute.asyn complete will callback");
// 除了ListenableFuture,guava還提供了FutureCallback接口,相對來說更加方便一些.
ListeningExecutorService guavaExecutor2 = MoreExecutors
.listeningDecorator(Executors.newSingleThreadExecutor());
final ListenableFuture<String> listenableFuture2 = guavaExecutor2
.submit(new Callable<String>() {
@Override
public String call() throws Exception {
Thread.sleep(1000);
System.out.println("asyncThreadName:"
+ Thread.currentThread().getName());
return "this is guava future call.support async callback using FutureCallback";
}
});
// 注意這里沒用指定執行回調的線程池,從輸出可以看出，默認是和執行異步操作的線程是同一個.
Futures.addCallback(listenableFuture2, new FutureCallback<String>() {
@Override
public void onSuccess(String result) {
System.out
.println("async callback(using FutureCallback) result:"
+ result);
System.out.println("execute callback threadName:"
+ Thre }ad.currentThread().getName());
@Override
public void onFailure(Throwable t) {
}
});
}
}
2.總結:利用guava的ListenableFuture和FutureCallback方便的實現異步回調.
posted on 2014-02-27 14:54
landon 閱讀(7194)
評論(3) 編輯 收藏 所屬分類:
Program