//最簡單的異步調(diào)用，默認(rèn)使用 ForkJoinPool.commonPool()
CompletableFuture<Integer> computeFuture = CompletableFuture.supplyAsync(() -> {
    Thread.sleep(1000);  // 模擬耗時(shí)計(jì)算
    return 42;
});

//自定義線程池
ExecutorService bizExecutor = Executors.newFixedThreadPool(5, r -> {
    Thread t = new Thread(r);
    t.setName("BizExecutor-" + t.getId());
    return t;
});

// 場(chǎng)景：用戶詳情頁需要聚合多個(gè)服務(wù)的數(shù)據(jù)
public CompletableFuture<UserProfile> getUserProfile(String userId) {
    // 并行調(diào)用三個(gè)獨(dú)立服務(wù)
    CompletableFuture<UserInfo> userInfoFuture = 
        userService.getUserInfoAsync(userId);
    CompletableFuture<List<Order>> ordersFuture = 
        orderService.getUserOrdersAsync(userId);
    CompletableFuture<List<Address>> addressesFuture = 
        addressService.getUserAddressesAsync(userId);
    // thenCombine等待兩個(gè)都完成，然后合并
    CompletableFuture<UserWithOrders> userWithOrders = userInfoFuture
        .thenCombine(ordersFuture, (user, orders) -> {
            return new UserWithOrders(user, orders);
        });
    // thenCompose前一個(gè)完成后再開始下一個(gè)
    CompletableFuture<String> personalizedGreeting = userInfoFuture
        .thenCompose(user -> 
            greetingService.getGreetingAsync(user.getLanguage(), user.getName())
        );
    // allOf 等待所有（3+個(gè)）任務(wù)完成
    return CompletableFuture.allOf(
            userWithOrders, 
            addressesFuture, 
            personalizedGreeting
        )
        .thenApply(v -> {
            // 所有都完成后的聚合
            return new UserProfile(
                userWithOrders.join().getUser(),
                userWithOrders.join().getOrders(),
                addressesFuture.join(),
                personalizedGreeting.join()
            );
        });
}

// 健壯的數(shù)據(jù)處理管道
CompletableFuture<Report> reportFuture = CompletableFuture
    .supplyAsync(() -> dataFetcher.fetchData(), dataExecutor)
    // exceptionally異常時(shí)提供降級(jí)值
    .exceptionally(ex -> {
        log.warn("數(shù)據(jù)獲取失敗，使用緩存", ex);
        return cacheService.getCachedData();
    })
    // 對(duì)數(shù)據(jù)做處理，同時(shí)捕獲處理中的異常
    .thenApplyAsync(data -> {
        try {
            return dataProcessor.process(data);
        } catch (ProcessingException e) {
            throw new CompletionException("處理失敗", e);
        }
    }, processExecutor)
    // handle統(tǒng)一處理成功和失敗
    .handle((processedData, ex) -> {
        if (ex != null) {
            // 失敗路徑
            metrics.recordFailure(ex);
            return Report.errorReport("系統(tǒng)繁忙，請(qǐng)稍后重試");
        } else {
            // 成功路徑
            return Report.successReport(processedData);
        }
    })
    // whenComplete無論成功失敗都執(zhí)行（類似finally）
    .whenComplete((report, ex) -> {
        // 資源清理、日志記錄等
        cleanResources();
        log.info("報(bào)告生成完成，狀態(tài)：{}", 
            ex == null ? "成功" : "失敗");
    });

public Result handleRequest() {
    CompletableFuture<Data> future = fetchDataAsync();
    return future.get();  // 阻塞，浪費(fèi)容器線程
}

//完全異步
public CompletableFuture<Result> handleRequestAsync() {
    return fetchDataAsync()
        .thenApply(data -> convertToResult(data))
        .exceptionally(ex -> Result.error("處理失敗"));
}

public class ThreadPoolConfig {
    // CPU密集型：核心數(shù)+1
    @Bean("cpuIntensivePool")
    public ExecutorService cpuIntensivePool() {
        int coreSize = Runtime.getRuntime().availableProcessors() + 1;
        return new ThreadPoolExecutor(
            coreSize, coreSize * 2, 60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1000),
            new NamedThreadFactory("cpu-pool")
        );
    }
    // IO密集型：可設(shè)置較大線程數(shù)
    @Bean("ioIntensivePool")  
    public ExecutorService ioIntensivePool() {
        return new ThreadPoolExecutor(
            20, 100, 60L, TimeUnit.SECONDS,
            new SynchronousQueue<>(),  // 無界隊(duì)列，快速響應(yīng)
            new NamedThreadFactory("io-pool")
        );
    }
    // 定時(shí)/超時(shí)任務(wù)：使用ScheduledExecutor
    @Bean("timeoutPool")
    public ScheduledExecutorService timeoutPool() {
        return Executors.newScheduledThreadPool(5, 
            new NamedThreadFactory("timeout-pool"));
    }
}