本文共 7042 字，大约阅读时间需要 23 分钟。

• 很多的Futures 类的方法需要它。（Futures工具类使用）
• 它比后来改造为ListenableFutrue更简单。（早点使用比重构更简单）
• 工具方法的提供者不需要提供Future和ListenableFuture方法的变体。（不需要兼容两套）

接口

一个传统的Futrue代表一个异步计算的结果：一个可能完成也可能没有完成输出结果的计算。

增加回调

很多用户喜欢使用 Futures.addCallback(ListenableFuture,FutureCallback,Executor)方法。

• onSuccess(v) 当未来成功执行的动作，基于计算结果
• onFailure(Throwable) 当未来失败执行的动作，基于失败

创建

相较于jdk提供的 ExecutorService.submit(Callable)方法来初始化一个异步计算。它返回一个常规的Future,

基础用法如下：

/** * 说明：使用例子代码 * @author carter * 创建时间： 2020年03月19日 9:54 上午 **/@Slf4jpublic class ListenableFutureUtils {    public static void main(String[] args) {ListeningExecutorService service = MoreExecutors.listeningDecorator(    Executors.newFixedThreadPool(10));        final ListenableFuture
   
     listenableFuture = service.submit(() -> {            try {                TimeUnit.SECONDS.sleep(5);            } catch (InterruptedException e) {                e.printStackTrace();            }            return new AResult(30, "male", 1);        });        Futures.addCallback(listenableFuture,                new FutureCallback
    
     () {                    @Override                    public void onSuccess(AResult aResult) {                        log.info("计算成功，{}",aResult);                    }                    @Override                    public void onFailure(Throwable throwable) {                        log.error("计算错误",throwable);                    }                },service);    }    @Data    @AllArgsConstructor    public static class AResult{        private Integer age;        private String sex;        private Integer id;    }}
    
   

相对的，如果你想从基于FutureTask的API转换过来，

如果你喜欢抽象的设置future的值，而不是实现一个方法然后计算值，可以考虑使用AbstractFuture或使用SettableFuture ； 

如果你必须转换Future为ListenableFuture,你别无选择，必须使用 JdkFutureAdapters.listenInPoolThread(Future)来转换Future为ListenableFuture

应用

使用ListenablFuture最重要的原因是可以使用链式异步操作。

代码如下：

package com.xxx.demo;import com.google.common.util.concurrent.AsyncFunction;import com.google.common.util.concurrent.Futures;import com.google.common.util.concurrent.ListenableFuture;import lombok.AllArgsConstructor;import lombok.Data;/** * 说明：异步操作链 * @author carter * 创建时间： 2020年03月19日 10:11 上午 **/public class ApplicationUtils {    public static void main(String[] args) {        Query query = new Query(30);        ListenableFuture
   
     rowKeyFuture = lookUp(query);        AsyncFunction
    
      queryFun = rowKey -> readData(rowKey);        final ListenableFuture
     
       queryResultListenableFuture =             Futures.transformAsync(rowKeyFuture, queryFun);    }    private static ListenableFuture
      
        readData(RowKey rowKey) {        return null;    }    private static ListenableFuture
       
         lookUp(Query query) {        return null;    }    @Data    @AllArgsConstructor    public static class RowKey {        private String id;    }    @Data    @AllArgsConstructor    public static class Query {        private Integer age;    }    @Data    @AllArgsConstructor    public static class QueryResult {        private String id;        private String age;    }}
       
      
     
    
   

很多其他高效支持的操作ListenableFuture提供，而Future不提供。

只要一个操作开始，其他多个操作应该开始，fan-out， 千帆竞发。

ListenableFuture可以实现这样的操作：它触发了所有请求的回调。

通过少量的工作，我们可以 fan-in.

触发一个ListenableFuture 来获得计算结果，当其他的Future结束的时候。

Futures.allAsList是一个例子。

方法介绍：

AsyncFunction<A,B> 提供了一个方法 ， ListenableFuture apply(A inpunt),它可以用来异步的转换值。

package com.xxx.demo;import com.google.common.collect.Lists;import com.google.common.util.concurrent.FutureCallback;import com.google.common.util.concurrent.Futures;import com.google.common.util.concurrent.ListenableFuture;import lombok.AllArgsConstructor;import lombok.Data;import lombok.extern.slf4j.Slf4j;import java.util.List;/** * 说明：成功执行结果汇集 * @author carter * 创建时间： 2020年03月19日 10:34 上午 **/@Slf4jpublic class Test3 {    public static void main(String[] args) {        List
    
     
      > querys = Lists.newLinkedList();        final ListenableFuture
      
       
        > successfulAsList =            Futures.successfulAsList(querys);        Futures.addCallback(successfulAsList, new FutureCallback
        
         
          >() { @Override public void onSuccess(List
          
            queryResults) { log.info("执行结果列表：{}",queryResults); } @Override public void onFailure(Throwable throwable) { log.error("执行失败",throwable); } }); } @Data @AllArgsConstructor public static class QueryResult{ private Integer age; }}
          
         
        
       
      
     
    

package com.xxx.demo;import com.google.common.util.concurrent.ListenableFuture;import com.google.common.util.concurrent.ListeningExecutorService;import com.google.common.util.concurrent.MoreExecutors;import lombok.AllArgsConstructor;import lombok.Data;import java.util.concurrent.Callable;import java.util.concurrent.Executors;/** * 说明：嵌套的ListenableFuture * @author carter * 创建时间： 2020年03月19日 10:43 上午 **/public class Test4 {    public static void main(String[] args) {        final ListeningExecutorService executorService = MoreExecutors            .listeningDecorator(Executors.newFixedThreadPool(2));        final ListeningExecutorService otherExecutorService = MoreExecutors            .listeningDecorator(Executors.newFixedThreadPool(2));        Callable
    
      otherCallback =  ()->new Foo("aaa");        final ListenableFuture
     
      
       > submit =                 executorService.submit(() -> otherExecutorService.submit(otherCallback));    }    @Data    @AllArgsConstructor    public static class Foo{        private String name;    }}