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

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

// 電商訂單處理流水線示例
CompletableFuture<Order> orderFuture = CompletableFuture
    // 階段1：創(chuàng)建訂單（有返回值）
    .supplyAsync(() -> orderService.createOrder(request), orderExecutor)
    // 階段2：驗證庫存（轉換結果）
    .thenApplyAsync(order -> {
        inventoryService.checkStock(order.getItems());
        return order.markAsValidated();
    }, inventoryExecutor)
    // 階段3：扣減庫存（消費結果，無返回）
    .thenAcceptAsync(order -> {
        inventoryService.deductStock(order.getItems());
        logger.info("庫存扣減完成，訂單號：{}", order.getId());
    }, inventoryExecutor)
    // 階段4：發(fā)送通知（純副作用操作）
    .thenRunAsync(() -> {
        notificationService.sendOrderCreated();
    }, notificationExecutor);

// 場景：用戶詳情頁需要聚合多個服務的數(shù)據(jù)
public CompletableFuture<UserProfile> getUserProfile(String userId) {
    // 并行調用三個獨立服務
    CompletableFuture<UserInfo> userInfoFuture = 
        userService.getUserInfoAsync(userId);
    CompletableFuture<List<Order>> ordersFuture = 
        orderService.getUserOrdersAsync(userId);
    CompletableFuture<List<Address>> addressesFuture = 
        addressService.getUserAddressesAsync(userId);
    // thenCombine等待兩個都完成，然后合并
    CompletableFuture<UserWithOrders> userWithOrders = userInfoFuture
        .thenCombine(ordersFuture, (user, orders) -> {
            return new UserWithOrders(user, orders);
        });
    // thenCompose前一個完成后再開始下一個
    CompletableFuture<String> personalizedGreeting = userInfoFuture
        .thenCompose(user -> 
            greetingService.getGreetingAsync(user.getLanguage(), user.getName())
        );
    // allOf 等待所有（3+個）任務完成
    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異常時提供降級值
    .exceptionally(ex -> {
        log.warn("數(shù)據(jù)獲取失敗，使用緩存", ex);
        return cacheService.getCachedData();
    })
    // 對數(shù)據(jù)做處理，同時捕獲處理中的異常
    .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)繁忙，請稍后重試");
        } else {
            // 成功路徑
            return Report.successReport(processedData);
        }
    })
    // whenComplete無論成功失敗都執(zhí)行（類似finally）
    .whenComplete((report, ex) -> {
        // 資源清理、日志記錄等
        cleanResources();
        log.info("報告生成完成，狀態(tài)：{}", 
            ex == null ? "成功" : "失敗");
    });

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

//完全異步
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ù)
    @Bean("ioIntensivePool")  
    public ExecutorService ioIntensivePool() {
        return new ThreadPoolExecutor(
            20, 100, 60L, TimeUnit.SECONDS,
            new SynchronousQueue<>(),  // 無界隊列，快速響應
            new NamedThreadFactory("io-pool")
        );
    }
    // 定時/超時任務：使用ScheduledExecutor
    @Bean("timeoutPool")
    public ScheduledExecutorService timeoutPool() {
        return Executors.newScheduledThreadPool(5, 
            new NamedThreadFactory("timeout-pool"));
    }
}