Java8 中增强 Future：CompletableFuture

增强的 Future：CompletableFuture

CompletableFuture（它实现了 Future 接口） 和 Future 一样，可以作为函数调用的契约。当你向它请求获得结果，如果数据还没有准备好，请求线程就会等待，直到数据准备好后返回。

异步执行

@Test
public void testFuture() throws ExecutionException, InterruptedException {
    long t1 = System.currentTimeMillis();
    Future<List<Integer>> listFuture = getListAsync();
    System.out.println("do something...");
    Thread.sleep(2_000L);
    System.out.println("getList...");
    System.out.println(listFuture.get());
    System.out.println("spendTime = " + (System.currentTimeMillis() - t1));
}
private Future<List<Integer>> getListAsync() {
    CompletableFuture<List<Integer>> resultFuture = new CompletableFuture<>();
    new Thread( () -> {
        try {
            Thread.sleep(3_000L);
            resultFuture.complete(Lists.newArrayList(1, 2, 3));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }).start();
    return resultFuture;
}

执行结果：

do something...
getList...
[1, 2, 3]
spendTime = 3137

以上代码中，do something 指主线程在调用过 Future 的异步接口取得凭证后，即可继续向下执行，直至 getList 需要通过凭证取得异步计算结果时，再通过 get 的方式取得。

如果采用同步调用的方式，那么以上程序则需要 3 + 2 共 5s 的时间。

使用 supplyAsync 创建 CompletableFuture

CompletableFuture 提供了更轻巧的工厂方法

@Test
public void testFuture() throws ExecutionException, InterruptedException {
    long t1 = System.currentTimeMillis();
//    Future<List<Integer>> listFuture = getListAsync();
    CompletableFuture<List<Integer>> listFuture = CompletableFuture.supplyAsync(OrderThriftServiceTest::getList);
    System.out.println("do something...");
    Thread.sleep(2_000L);
    System.out.println("getList...");
    System.out.println(listFuture.get());
    System.out.println("spendTime = " + (System.currentTimeMillis() - t1));
}
private static List<Integer> getList() {
    try {
        Thread.sleep(3_000L);
        return Lists.newArrayList(1,2,3,4,5);
    } catch (InterruptedException e) {
        e.printStackTrace();
        return Lists.newArrayList();
    }
}

对两个 CompletableFuture 的整合

compose 与 combine

compose，在一个 CompletableFuture 执行完毕后，将执行结果通过 Function 传递给下一个 Future 进行处理。

combine，将两个 CompletableFuture 整合起来，无论它们是否存在依赖。它接受 BiFunction 第二参数，这个参数定义了当两个 CompletableFuture 对象执行完计算后，结果如何合并。

两者都提供了后缀为 Async 的版本，该方法会将后续的任务提交到一个线程池中。其中 composeAsync 其实意义不大，因为 compose 操作的时间取决于第一个 CompletableFuture 的执行时间，composeAsync 相较 compose 消耗更多的线程切换开销。

一点实际应用

在服务化的项目中，一个服务调用另一个服务所提供的批量接口，如果一次调用的量过大那么将耗费很长时间，通过 CompletableFuture 可以暂缓一些时间，用作做执行别的任务

更加优化的做法是将大批量请求分成若干个合理大小的小批量请求（每个服务一般都是多机部署的，这样多个请求通过负载均衡打到多台机器，达到了并行运算的效果），还是通过 CompletableFuture 的方式，最终将结果进行组合，组合的过程就可以用 combine 来进行，而不是先 get 再 addAll 这种 low 的做法。

CompletableFuture<List<Integer>> f1 = CompletableFuture.supplyAsync(OrderThriftServiceTest::getList);
CompletableFuture<List<Integer>> f2 = CompletableFuture.supplyAsync(OrderThriftServiceTest::getList);
CompletableFuture<List<Integer>> f3 = f1.thenCombineAsync(f2, (l1, l2) -> Stream.concat(l1.stream(), l2.stream()).collect(toList()));
// doSomething...
f3.get();

参考资料

[1] Java8 实战. 第 11 章

[2] Java 高并发程序设计. 6.5