CommpetableFuture使用anyOf过程中的一些优化思考

干货满满张哈希

发布于 2021-04-12 14:23:23

5400

发布于 2021-04-12 14:23:23

文章被收录于专栏：干货满满张哈希

系列目录：

CompletableFuture的allOf

首先我们看看allOf的定义：

public static CompletableFuture allOf(CompletableFuture... cfs) {
    // ...
}

这个方法接受若干个返回不同类型的CompletableFuture为参数，返回一个返回为空（Void）的CompletableFuture。也就是说，这个方法其实就是返回一个在所有参数完成之后也完成的返回为空（Void）的CompletableFuture，也就是充当一个signaling device

这个方法很好，尤其是并发获取多种io的结果的时候。但是用这个方法，带来了很多不便，最大的不便就是，返回是Void，而不是所有的参数的返回。这样导致我们，需要在聚合这些结果的那个服务方法里面，把最终结果封装好，否则，获取的就是一个Void。举个例子：

假设我的一个服务方法的返回是多个接口在使用，这个方法需要同时调用三个io等待他们都返回时，利用这三个io的返回，拼装成接口需要的字段。对于这个场景，我们可以有两种写法，第一种是基于回调的写法，第二种是基于返回的写法，两种都OK，看个人习惯，我个人倾向于基于返回的写法，这样代码是瀑布式的，基于回调的会导致多层嵌套，导致代码可读性降低。

** 结果类：**

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public static class Result {
   private String string;
   private List strings;
   private List integers;
}

** 基于回调：**

public static void baseOnCallBack(CompletableFuture resultCompletableFuture) {
   CompletableFuture> result1 = CompletableFuture.supplyAsync(() -> {
       //模拟io
       try {
           TimeUnit.MILLISECONDS.sleep(ThreadLocalRandom.current().nextLong(1000));
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       return Lists.newArrayList("a", "b", "c");
   });
   CompletableFuture> result2 = CompletableFuture.supplyAsync(() -> {
       //模拟io
       try {
           TimeUnit.MILLISECONDS.sleep(ThreadLocalRandom.current().nextLong(1000));
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       return Lists.newArrayList(1, 2, 3);
   });
   CompletableFuture result3 = CompletableFuture.supplyAsync(() -> {
       //模拟io
       try {
           TimeUnit.MILLISECONDS.sleep(ThreadLocalRandom.current().nextLong(1000));
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       return "hash-test";
   });

   CompletableFuture.allOf(result1, result2, result3).thenAcceptAsync(v -> {
       resultCompletableFuture.complete(Result.builder()
               //一定存在的，因为已经完成了
               .string(result3.join())
               .strings(result1.join())
               .integers(result2.join())
               .build());
   });
}

** 基于返回：**

public static CompletableFuture baseOnReturn() {
   CompletableFuture completableFuture = new CompletableFuture();
   CompletableFuture> result1 = CompletableFuture.supplyAsync(() -> {
       //模拟io
       try {
           TimeUnit.MILLISECONDS.sleep(ThreadLocalRandom.current().nextLong(1000));
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       return Lists.newArrayList("a", "b", "c");
   });
   CompletableFuture> result2 = CompletableFuture.supplyAsync(() -> {
       //模拟io
       try {
           TimeUnit.MILLISECONDS.sleep(ThreadLocalRandom.current().nextLong(1000));
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       return Lists.newArrayList(1, 2, 3);
   });
   CompletableFuture result3 = CompletableFuture.supplyAsync(() -> {
       //模拟io
       try {
           TimeUnit.MILLISECONDS.sleep(ThreadLocalRandom.current().nextLong(1000));
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       return "hash-test";
   });
   CompletableFuture.allOf(result1, result2, result3).thenAcceptAsync(v -> {
       completableFuture.complete(Result.builder()
               //一定存在的，因为已经完成了
               .string(result3.join())
               .strings(result1.join())
               .integers(result2.join())
               .build());
   });
   return completableFuture;
}

基于回调的接口使用结果：

CompletableFuture completableFuture = new CompletableFuture();
baseOnCallBack(completableFuture);
completableFuture = completableFuture.thenAcceptAsync(result -> {
    System.out.println("baseOnCallback: " + result);
});

基于返回的接口使用结果：

CompletableFuture voidCompletableFuture = baseOnReturn().thenAcceptAsync(result -> {
    System.out.println("baseOnReturn: " + result);
});

可以看出，一层嵌套也是基于返回的代码看上去更优雅。

我们再来思考下，如果allOf中的所有CompletableFuture都返回的是同一个类型的结果，例如String，那么可不可以让allOf直接返回List呢？

我们可以将一个allOf变成多个allOf这么实现：

public static  CompletableFuture> allOf(Collection> futures) {
    return futures.stream().collect(Collectors.collectingAndThen(
                    Collectors.toList(),
                    l -> CompletableFuture.allOf(l.toArray(new CompletableFuture[0]))
                            .thenApply(v -> l.stream().map(CompletableFuture::join).collect(Collectors.toList()))
            )
    );
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2019/11/18 ，如有侵权请联系 cloudcommunity@tencent.com 删除

spring

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

spring

登录后参与评论

0 条评论

热度