如何在循环中调用completable future并合并所有结果？

Question

我正在努力实现这样的目标。这是一个虚构的例子，表达了这个意图。

我希望所有可完成的未来都能执行，并将所有结果合并为一个结果，然后返回。因此，对于下面的示例，集合allResults应该有字符串“1”、“2”、“3”，每个字符串有3次。我希望它们都并行运行，而不是串行运行。

任何关于未来我可以使用什么API来实现这一点的建议都会非常有用。

public class Main {


    public static void main(String[] args) {

        int x = 3;
        List<String> allResuts;

        for (int i = 0; i < x; i++) {

           //call getCompletableFutureResult() and combine all the results
        }

    }

    public static CompletableFuture<List<String>> getCompletableFutureResult() {

        return CompletableFuture.supplyAsync(() -> getResult());
    }

    private static List<String> getResult() {


        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");

        return list;
    }


}

Answer 1

您无法在第一个for循环中收集结果，因为这意味着您在等待前一个任务的结果时，甚至没有开始其他任务。

因此，一旦所有任务开始，就开始收集结果。

public static void main(String[] args) throws Exception
{
  int x = 3;

  Queue<CompletableFuture<List<String>>> cfs = new ArrayDeque<>(x);
  for (int i = 0; i < x; i++)
  {
    cfs.add(getCompletableFutureResult());
  }

  List<String> allResuts = new ArrayList<>();
  for (CompletableFuture<List<String>> cf : cfs)
    allResuts.addAll(cf.get());

  System.out.println(allResuts);
}

Answer 2

文卡塔·拉朱回答了一个问题。Raju在future上使用了get调用，这是一个阻塞调用，终止了异步风格编码的主要目的。永远避免做“未来”的事。

有很多内置方法围绕着处理未来的值而构建，比如应用、接受、组合、组合等等。

CompletableFuture.allOf方法旨在用于处理多个期货。

它有以下签名

public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)

旁注：CompletableFuture。当你只关心第一个要完成的未来时，可以使用anyOf。当你需要完成所有期货交易时，请使用allOf。

我将使用CompletableFuture按照以下方式编写您的规范。全部。

public class DorjeeTest {


    public static CompletableFuture<List<String>> getCompetableFutureResult() {
        return CompletableFuture.supplyAsync(() -> getResult());
    }
    public static List<String> getResult() {
        return Lists.newArrayList("one", "two", "three");
    }

    public static void testFutures() {
        int x = 3;
        List<CompletableFuture<List<String>>> futureResultList = Lists.newArrayList();
        for (int i = 0; i < x; i++) {
            futureResultList.add(getCompetableFutureResult());
        }

        CompletableFuture[] futureResultArray = futureResultList.toArray(new CompletableFuture[futureResultList.size()]);

        CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(futureResultArray);

        CompletableFuture<List<List<String>>> finalResults = combinedFuture
                .thenApply(voidd ->
                        futureResultList.stream()
                                .map(future -> future.join())
                        .collect(Collectors.toList()));

        finalResults.thenAccept(result -> System.out.println(result));
    }


    public static void main(String[] args) {
        testFutures();
        System.out.println("put debug break point on this line...");

    }
}