Java中如何用CompletableFuture组合异步操作

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

public class CompletableFutureExample {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            // 模拟耗时操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return "Error in Future 1";
            }
            return "Result from Future 1";
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            // 模拟另一个耗时操作
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return "Error in Future 2";
            }
            return "Result from Future 2";
        });

        // 使用 thenCombine 组合两个 Future 的结果
        CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (result1, result2) -> {
            return result1 + " and " + result2;
        });

        // 获取组合后的结果
        String finalResult = combinedFuture.get();
        System.out.println("Combined Result: " + finalResult);

        // 使用 thenCompose 链接 Future
        CompletableFuture<String> composedFuture = future1.thenCompose(result1 -> {
            return CompletableFuture.supplyAsync(() -> {
                return result1 + " processed further";
            });
        });

        String composedResult = composedFuture.get();
        System.out.println("Composed Result: " + composedResult);

        // 使用 allOf 等待所有 Future 完成
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2);

        allFutures.get(); // 等待所有 future 完成
        System.out.println("All futures completed");

        // 处理异常
        CompletableFuture<String> futureWithError = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("Simulated error");
        }).exceptionally(ex -> {
            System.err.println("Caught exception: " + ex.getMessage());
            return "Recovered from error";
        });

        String errorResult = futureWithError.get();
        System.out.println("Error Result: " + errorResult);
    }
}