在Java，我如何处理CompletableFutures并得到第一个完成的预期结果？

Question

通常，对于CompletableFuture，我会调用thenApply或它的其他方法，以便在结果可用时立即执行某些操作。然而，我现在有一种情况，我想处理结果，直到我收到一个肯定的结果，然后忽略所有进一步的结果。

如果我只是想获取第一个可用的结果，我可以使用CompletableFuture.anyOf（尽管我讨厌为了调用anyOf而将列表转换为数组）。但那不是我想要的。我想取第一个结果，如果它没有理想的结果，那么我想处理第二个可用的结果，依此类推，直到得到理想的结果。

下面是一个简单的示例，它遍历所有结果，并返回它找到的第一个大于9的值。（注意，这不是我真正的任务，这只是一个简单的例子。）

public Integer findFirstGt9(List<CompletableFuture<Integer>> results) {
    for(CompletableFuture<Integer> result : results) {
        Integer v = result.get();
        if(v > 9)
            return v;
    }
    return null;
}

当然，该示例从一开始就查看结果，而不是在结果完成时查看结果。这里有一个实现了我想要的，但代码要复杂得多。

public Integer findFirstGt9(List<CompletableFuture<Integer>> results) {
    AtomicInteger finalResult = new AtomicInteger();
    CountDownLatch latch = new CountDownLatch(results.size());
    for(CompletableFuture<Integer> result : results) {
        result.whenComplete((v,e) -> {
            if(e!=null) {
                Logger.getLogger(getClass()).error("",e);
            } else if(v > 9) {
                finalResult.set(v);
                while(latch.getCount() > 0)
                    latch.countDown();
                return;
            }
            latch.countDown();
        });
    }
    latch.await();

    if(finalResult.get() > 9)
        return finalResult.get();
    return null;
}    

有没有一个api我可以这样做？

public Integer findFirstGt9(List<CompletableFuture<Integer>> results) {
    Iterator<Integer> resultIt = getResultsAsAvailable(results);
    for(; resultIt.hasNext();) {
        Integer v = resultIt.next();
        if(v > 9)
            return v;
    }
    return null;
}

或者更好：

public Integer findFirstGt9(List<CompletableFuture<Integer>> results) {
    return getFirstMatch(results, r -> {return r > 9;});
}

Answer 1

我不知道在JDK或其他地方有任何这样的API。你可以自己滚。

如果未来已经完成，completablefuture#complete（和completeexceptional)不会执行任何操作，您可以利用这一事实。

如果尚未完成，则将get()和相关方法返回的值设置为给定值。

创建新的最终结果completablefuture。如果条件适用，将尝试complete此最终结果的每个futures添加一个continuation。未来将以第一次成功而告终。但是，如果没有成功，您显然需要null作为结果。您可以使用allof创建completablefuture来尝试使用null来完成最终结果。

类似于

public static <T> CompletableFuture<T> firstOrNull(List<CompletableFuture<T>> futures, Predicate<T> condition) {
    CompletableFuture<T> finalResult = new CompletableFuture<>();
    // attempt to complete on success
    futures.stream().forEach(future -> future.thenAccept(successResult -> {
        if (condition.test(successResult))
            finalResult.complete(successResult);
    }));
    CompletableFuture<?> all = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
    all.thenRun(() -> {
        finalResult.complete(null);
    });
    return finalResult;
}

您需要支付无操作调用的开销。

您可以根据需要将null更改为某些默认值，或者以不同的方式处理异常(completeexceptionary)。您必须使用whencomplete或handle而不是上面的thenaccept来访问exception。

Answer 2

您可以使用以下解决方案：

public static <T> CompletableFuture<T> anyMatch(
    List<? extends CompletionStage<? extends T>> l, Predicate<? super T> criteria) {

    CompletableFuture<T> result=new CompletableFuture<>();
    Consumer<T> whenMatching=v -> { if(criteria.test(v)) result.complete(v); };
    CompletableFuture.allOf(l.stream()
        .map(f -> f.thenAccept(whenMatching)).toArray(CompletableFuture<?>[]::new))
    .whenComplete((ignored, t) ->
        result.completeExceptionally(t!=null? t: new NoSuchElementException()));
    return result;
}

基本原理与Pillar的回答中相同，然而，有一些不同之处：

• 泛型签名更灵活。
• 创建CompletableFuture.AllOf所需的数组与注册源Futures的后续操作相结合。作为一个副作用，allof操作的处理程序依赖于完成所有尝试来完成结果，而不是仅依赖于原始的期货。这使得实际所需的依赖关系显式化。这样，当我们用thenAccept替换所有thenAcceptAsync时，它甚至可以工作。
• 此解决方案以nosuchelementException完成，而不是在没有结果满足条件的情况下返回null。如果至少有一个future异常完成，并且没有匹配结果的成功完成，则中继发生的一个异常。

你可以用

List<CompletableFuture<Integer>> list=Arrays.asList(
    CompletableFuture.supplyAsync(()->5),
    CompletableFuture.supplyAsync(()->{throw new RuntimeException(); }),
    CompletableFuture.supplyAsync(()->42),
    CompletableFuture.completedFuture(0)
);
anyMatch(list, i -> i>9)
    .thenAccept(i->System.out.println("got "+i))
    // optionally chain with:
    .whenComplete((x,t)->{ if(t!=null) t.printStackTrace(); });