completablefuture.allof方法

CompletableFuture.allOf() 方法是一个静态方法，用于创建一个包含多个CompletableFuture的CompletableFuture，当所有 CompletableFuture 都完成时，它将返回一个 CompletableFuture<Void>。

相关问题

java CompletableFuture.allOf 使用

CompletableFuture.allOf方法用于等待多个CompletableFuture完成，并返回一个新CompletableFuture，该CompletableFuture在所有输入CompletableFuture完成后完成。它不会返回任何结果，只是用于等待所有的CompletableFuture完成。

下面是一个使用CompletableFuture.allOf的示例代码[^2]：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Result from Future 1";
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Result from Future 2";
        });

        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Result from Future 3";
        });

        CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2, future3);

        try {
            allFutures.get();
            System.out.println("All futures completed");
            System.out.println("Result from Future 1: " + future1.get());
            System.out.println("Result from Future 2: " + future2.get());
            System.out.println("Result from Future 3: " + future3.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，我们创建了三个CompletableFuture对象，每个对象都模拟了一个耗时的操作。然后，我们使用CompletableFuture.allOf方法等待所有的CompletableFuture完成。最后，我们通过调用get方法来获取每个CompletableFuture的结果。

CompletableFuture.allOf 异常处理

CompletableFuture.allOf方法用于组合多个CompletableFuture对象，并在所有任务完成后返回一个新的CompletableFuture对象。然而，CompletableFuture.allOf方法本身并不处理异常，它只是等待所有任务完成。

要处理CompletableFuture.allOf方法中的异常，可以使用whenComplete方法。whenComplete方法可以在任务完成时触发回调函数，无论是正常完成还是发生异常。通过在whenComplete方法中处理异常，我们可以确保异常得到正确的传播和处理。

下面是一个示例代码，演示了如何使用CompletableFuture.allOf方法和whenComplete方法来处理异常：

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // 任务1
    throw new RuntimeException("Oops!");
});

CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    // 任务2
    return 42;
});

CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2);

CompletableFuture<String> result = allFutures.thenApply(v -> {
    // 所有任务完成后的处理
    if (future1.isCompletedExceptionally()) {
        // 处理任务1的异常
        Throwable ex = future1.getCompletionException();
        System.out.println("Error occurred in future1: " + ex);
        return "Error";
    } else if (future2.isCompletedExceptionally()) {
        // 处理任务2的异常
        Throwable ex = future2.getCompletionException();
        System.out.println("Error occurred in future2: " + ex);
        return "Error";
    } else {
        // 所有任务正常完成
        return "Success";
    }
});

result.join(); // 等待结果

在上面的代码中，我们使用CompletableFuture.allOf方法组合了future1和future2，并使用thenApply方法处理所有任务完成后的结果。在thenApply方法中，我们通过判断每个任务是否发生异常来处理异常情况，并返回相应的结果。