java - 测试 CompletableFuture.allOf。加入需要永远

Question

我正在尝试测试使用 CompletableFuture.allOf 的方法。
我模拟 future，以便它们在加入时返回所需的值。
由于某种我无法理解的原因。结果的 join() 需要永远。
任何帮助都可以!

提前致谢。

    @Mock private CompletableFuture<String> future1; // for sequence test
    @Mock private CompletableFuture<String> future2; // for sequence test
    @Mock private CompletableFuture<String> future3; // for sequence test

    private BBService bbServiceTest;

    @Test
    public void testSequence() {
        final String[] expectedResults = {"res1", "res2", "res3"};
        List<CompletableFuture<String>> futures = new Vector<>();

        when(future1.join()).thenReturn(expectedResults[0]);
        when(future2.join()).thenReturn(expectedResults[1]);
        when(future3.join()).thenReturn(expectedResults[2]);

        futures.add(future1);
        futures.add(future2);
        futures.add(future3);

        bbServiceTest.sequence(futures).join();
        Assert.assertTrue(future1.isDone());
        Assert.assertTrue(future2.isDone());
        Assert.assertTrue(future3.isDone());

//        for (int i = 0; i < actualResults.size(); i++) {
//            Assert.assertEquals(expectedResults[i], actualResults.get(i));
//        }
    }

BBService 中的序列方法:

    public <T> CompletableFuture<List<T>> sequence(List<CompletableFuture<T>> futuresList) {
        return CompletableFuture
                .allOf(futuresList.toArray(new CompletableFuture[0])) // (1)
                .thenApply(v ->
                        futuresList.stream()
                                .map(CompletableFuture::join)
                                .collect(Collectors.toList())
                );
    }

Answer 1

那是因为你的 future 永远不会完成。 CompletableFuture.allOf 返回一个新的 CompletableFuture，当所有给定的 CompletableFutures 完成时，该 CompletableFuture 也完成。

future1.complete()、future2.complete() 和 future3.complete() 永远不会被调用。

CompletableFuture.join() 如果 future 完成，则返回结果。因为您在代码中模拟 future，所以即使未完成，它们也会在 join 上返回 expectedResults 中定义的字符串。但这正是问题所在。他们没有完成。这就是测试未完成的原因。

我稍微调整了您的测试类以演示它是如何工作的:

public class FutureTest {
    @Test
    public void testSequence1() {
        List<CompletableFuture<String>> futures = getFutures();
        CompletableFuture<Void> myCombinedFuture = sequence(futures);
        // here we complete each future
        futures.forEach(future -> future.complete("future-completed"));
        myCombinedFuture.join();

        // this works because we completed all futures before
        Assert.assertTrue(myCombinedFuture.isDone());
    }

    @Test
    public void testSequence2() {
        List<CompletableFuture<String>> futures = getFutures();
        CompletableFuture<Void> myCombinedFuture = sequence(futures);
        futures.get(0).complete("completed-future1");
        futures.get(1).complete("completed-future2");

        myCombinedFuture.join();
        // this does not work because future3 is not completed -> we wait forever
        Assert.assertTrue(myCombinedFuture.isDone());
    }

    @Test
    public void testSequence3() {
        List<CompletableFuture<String>> futures = getFutures();
        CompletableFuture<Void> myCombinedFuture = sequence(futures);
        futures.get(0).complete("completed-future1");
        futures.get(1).complete("completed-future2");

        // complete future 3 asynchronous after 2 seconds
        futures.get(2).completeAsync(() -> {
            // wait for 2 seconds
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            return "completed-future3";
        });

        myCombinedFuture.join();
        // after 2 seconds all futures are completed and the test will pass
        Assert.assertTrue(myCombinedFuture.isDone());
    }

    public CompletableFuture<Void> sequence(
            List<CompletableFuture<String>> futuresList) {
        return CompletableFuture.allOf(
            futuresList.toArray(new CompletableFuture[0]));
    }

    public List<CompletableFuture<String>> getFutures() {
        return List.of(
                new CompletableFuture<>(),
                new CompletableFuture<>(),
                new CompletableFuture<>()
        );
    }
}