Java 列出可完成的未来

您能告诉我如何在父CompletableFuture中等待CompletableFuture列表，收集结果并返回吗

CompletableFuture<TerminateEnvironmentResponse> future = CompletableFuture.supplyAsync(() -> {
  TerminateEnvironmentResponse terminateEnvironmentResponse = new TerminateEnvironmentResponse();
  List<EnvironmentDto> environmentDtoList = ...
  environmentDtoList.forEach(environmentDto -> {
    _cloudFormationService.destroyStack(environmentDto)
        .whenComplete((result, ex) -> {
          if (ex != null) {
            terminateEnvironmentResponse.setError(true);
          } else {
            int count = terminateEnvironmentResponse.getCount();
            terminateEnvironmentResponse.setCount(++count);
          }
        });
  });
  return terminateEnvironmentResponse;
});
return future;

CompletableFuture=CompletableFuture.supplyAsync（（）->{
TerminateEnvironmentResponse TerminateEnvironmentResponse=新TerminateEnvironmentResponse（）；
列表环境数据列表=。。。
environmentDtoList.forEach（environmentDto->{
_cloudFormationService.destroyStack（environmentDto）
.完成时（结果，例如）->{
如果（ex！=null）{
terminateEnvironmentResponse.setError（true）；
}否则{
int count=terminateEnvironmentResponse.getCount（）；
terminateEnvironmentResponse.setCount（++count）；
}
});
});
返回terminateEnvironmentResponse；
});
回归未来；

到目前为止已决定

  static <V> CompletableFuture<Collection<V>> allOf(Collection<CompletableFuture<V>> futures) {
    return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
        .thenApply(v -> futures.stream()
            .map(CompletableFuture::join)
            .collect(toList()));
  }

  private CompletableFuture<DeleteStackResult> map(CompletableFuture<DeleteStackResponse> responseCompletableFuture) {
    return responseCompletableFuture.thenApply(res -> new DeleteStackResult(res, null))
        .exceptionally(ex -> new DeleteStackResult(null, ex));
  }

  @Data
  @AllArgsConstructor
  static class DeleteStackResult {

    private DeleteStackResponse response;
    private Throwable exception;
  }


  @Override   public CompletableFuture<TerminateEnvironmentResponse> terminateEnvironment(UserDto userDto) {
    List<CompletableFuture<DeleteStackResult>> completableFutureList = new ArrayList();
    List<EnvironmentDto> environmentDtoList = _environmentService.getEnvironments();
    environmentDtoList.forEach(environmentDto -> completableFutureList.add(map(_cloudFormationService.destroyStack(environmentDto))));

    CompletableFuture<Collection<DeleteStackResult>> collectionCompletableFuture = allOf(completableFutureList);

    CompletableFuture<TerminateEnvironmentResponse> future = collectionCompletableFuture.thenApply(resultCollection -> {
      TerminateEnvironmentResponse terminateEnvironmentResponse = new TerminateEnvironmentResponse();
      resultCollection.forEach(deleteStackResult -> {
        int count = terminateEnvironmentResponse.getCount();
        terminateEnvironmentResponse.setCount(++count);
        if (deleteStackResult.getException() != null) {
          terminateEnvironmentResponse.setError(true);
        }
      });
      return terminateEnvironmentResponse;
    });
    return future;   }

static CompletableFuture allOf（集合未来）{
return CompletableFuture.allOf（futures.toArray（新的CompletableFuture[0]））
.thenApply（v->futures.stream（）
.map（CompletableFuture:：join）
.collect（toList（））；
}
专用CompletableFuture映射（CompletableFuture响应CompletableFuture）{
返回responseCompletableFuture。然后应用（res->new DeleteStackResult（res，null））
.异常情况（ex->new DeleteStackResult（null，ex））；
}
@资料
@AllArgsConstructor
静态类DeleteStackResult{
私人回应；
私人可抛弃例外；
}
@重写公共CompletableFuture terminateEnvironment（UserDto到UserDto）{
List completableFutureList=新建ArrayList（）；
List environmentDtoList=_environmentService.getEnvironments（）；
forEach（environmentDto->completableFutureList.add（map（_cloudFormationService.destroyStack（environmentDto）））；
CompletableFuture collectionCompletableFuture=allOf（completableFutureList）；
CompletableFuture=collectionCompletableFuture.thenApply（resultCollection->{
TerminateEnvironmentResponse TerminateEnvironmentResponse=新TerminateEnvironmentResponse（）；
resultCollection.forEach（deleteStackResult->{
int count=terminateEnvironmentResponse.getCount（）；
terminateEnvironmentResponse.setCount（++count）；
if（deleteStackResult.getException（）！=null）{
terminateEnvironmentResponse.setError（true）；
}
});
返回terminateEnvironmentResponse；
});
返回未来；}

CompletableFuture.allOf

。每个CompletableFuture的结果如何？您可以阅读javadoc:

给定CompletableFuture的结果（如果有）不会反映在返回的CompletableFuture中，但可以通过单独检查来获得。

取决于您的结果的构建方式，您还可以使用

然后使用combine

将未来减少为一。此外，您的

getCount

→ <代码>设置计数不是原子的，因此不是线程安全的。