概念

        ListenableFuture 顧名思義就是可以監聽的Future，它是對java原生Future的擴展增強。我們知道Future表示一個異步計算任務，當任務完成時可以得到計算結果。如果我們希望一旦計算完成就拿到結果展示給用戶或者做另外的計算，就必須使用另一個線程不斷的查詢計算狀態。這樣做，代碼復雜，而且效率低下。使用 ListenableFuture Guava幫我們檢測Future是否完成了，如果完成就自動調用回調函數，這樣可以減少并發程序的復雜度。      

        推薦使用第二種方法，因為第二種方法可以直接得到Future的返回值，或者處理錯誤情況。本質上第二種方法是通過調動第一種方法實現的，做了進一步的封裝。

另外ListenableFuture還有其他幾種內置實現：

1. SettableFuture：不需要實現一個方法來計算返回值，而只需要返回一個固定值來做為返回值，可以通過程序設置此Future的返回值或者異常信息

   </li>

2. CheckedFuture： 這是一個繼承自ListenableFuture接口，他提供了checkedGet()方法，此方法在Future執行發生異常時，可以拋出指定類型的異常。

    

   </li> </ol>

       RateLimiter類似于JDK的信號量Semphore，他用來限制對資源并發訪問的線程數，本文介紹RateLimiter使用

   代碼示例

   import java.util.concurrent.Callable;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.Executors;
   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;
   import com.google.common.util.concurrent.RateLimiter;
   public class ListenableFutureDemo {
       public static void main(String[] args) {
           testRateLimiter();
           testListenableFuture();
       }
   
   /**
    * RateLimiter類似于JDK的信號量Semphore，他用來限制對資源并發訪問的線程數
    */
   public static void testRateLimiter() {
       ListeningExecutorService executorService = MoreExecutors
               .listeningDecorator(Executors.newCachedThreadPool());
   
       RateLimiter limiter = RateLimiter.create(5.0); // 每秒不超過4個任務被提交
   
       for (int i = 0; i < 10; i++) {
           limiter.acquire(); // 請求RateLimiter, 超過permits會被阻塞
   
           final ListenableFuture<Integer> listenableFuture = executorService
                   .submit(new Task("is "+ i));
       }
   }
   
   public static void testListenableFuture() {
       ListeningExecutorService executorService = MoreExecutors
               .listeningDecorator(Executors.newCachedThreadPool());
   
       final ListenableFuture<Integer> listenableFuture = executorService
               .submit(new Task("testListenableFuture"));
   
   
       //同步獲取調用結果
       try {
           System.out.println(listenableFuture.get());
       } catch (InterruptedException e1) {
           e1.printStackTrace();
       } catch (ExecutionException e1) {
           e1.printStackTrace();
       }
   
       //第一種方式
       listenableFuture.addListener(new Runnable() {
           @Override
           public void run() {
               try {
                   System.out.println("get listenable future's result "
                           + listenableFuture.get());
               } catch (InterruptedException e) {
                   e.printStackTrace();
               } catch (ExecutionException e) {
                   e.printStackTrace();
               }
           }
       }, executorService);
   
       //第二種方式
       Futures.addCallback(listenableFuture, new FutureCallback<Integer>() {
           @Override
           public void onSuccess(Integer result) {
               System.out
                       .println("get listenable future's result with callback "
                               + result);
           }
   
           @Override
           public void onFailure(Throwable t) {
               t.printStackTrace();
           }
       });
   }
   
   }
   class Task implements Callable<Integer> {
       String str;
       public Task(String str){
           this.str = str;
       }
       @Override
       public Integer call() throws Exception {
           System.out.println("call execute.." + str);
           TimeUnit.SECONDS.sleep(1);
           return 7;
       }
   }</pre></h1>
   Guava版本
   <dependency>
               <groupId>com.google.guava</groupId>
               <artifactId>guava</artifactId>
               <version>14.0.1</version>
           </dependency>
   來自：http://my.oschina.net/cloudcoder/blog/359598