一、CompletableFuture核心特性

Java 8+的CompletableFuture为异步编程提供了强大支持：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// 自定义线程池（避免使用默认ForkJoinPool）
ExecutorService executor = Executors.newFixedThreadPool(10);

// 基本异步任务
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 模拟耗时操作
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    return "任务结果";
}, executor);

// 异步回调处理
future.thenApplyAsync(result -> {
    System.out.println("处理结果: " + result);
    return result.toUpperCase();
}, executor).exceptionally(ex -> {
    System.out.println("异常处理: " + ex.getMessage());
    return "默认值";
});

核心优势：链式调用、异常处理、线程池控制、组合操作

二、高级任务编排模式

// 模拟三个独立服务调用
CompletableFuture<String> userFuture = getUserInfo(userId);
CompletableFuture<Integer> orderFuture = getOrderCount(userId);
CompletableFuture<Double> balanceFuture = getBalance(userId);

// 合并多个异步结果
CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(
    userFuture, orderFuture, balanceFuture
);

// 统一处理结果
combinedFuture.thenRun(() -> {
    try {
        String user = userFuture.get();
        Integer orders = orderFuture.get();
        Double balance = balanceFuture.get();
        
        System.out.printf("用户%s, 订单数%d, 余额%.2f%n", 
            user, orders, balance);
    } catch (Exception e) {
        // 异常处理
    }
});

// 任务流水线：先登录再获取信息最后通知
CompletableFuture<String> authFuture = login(username, password);

authFuture.thenCompose(token -> 
    getUserProfile(token)  // 依赖登录结果
).thenAcceptBoth(
    getNotifications(),  // 并行执行
    (profile, notifications) -> {
        // 合并两个任务结果
        System.out.println("整合数据: " + profile + notifications);
    }
).exceptionally(ex -> {
    System.out.println("流程异常: " + ex.getMessage());
    return null;
});

三、性能优化实践

// 使用completeOnTimeout设置默认值
CompletableFuture<String> future = fetchData()
    .completeOnTimeout("默认值", 2, TimeUnit.SECONDS);

// 或者使用orTimeout直接超时异常
CompletableFuture<String> strictFuture = fetchData()
    .orTimeout(1, TimeUnit.SECONDS);

// 根据业务类型隔离线程池
ExecutorService ioPool = new ThreadPoolExecutor(
    10, 50, 60L, TimeUnit.SECONDS,
    new LinkedBlockingQueue(1000),
    new ThreadFactoryBuilder().setNameFormat("IO-%d").build()
);

ExecutorService cpuPool = new ThreadPoolExecutor(
    Runtime.getRuntime().availableProcessors(),
    Runtime.getRuntime().availableProcessors() * 2,
    60L, TimeUnit.SECONDS,
    new LinkedBlockingQueue(1000),
    new ThreadFactoryBuilder().setNameFormat("CPU-%d").build()
);

四、性能对比数据

测试环境：JDK 17/4核CPU/16GB内存

五、电商订单处理案例

public CompletableFuture<OrderResult> createOrder(OrderRequest request) {
    // 并行校验
    CompletableFuture<Boolean> stockCheck = checkStock(request);
    CompletableFuture<Boolean> riskCheck = riskControl(request);
    
    return CompletableFuture.allOf(stockCheck, riskCheck)
        .thenCompose(v -> {
            if (Boolean.TRUE.equals(stockCheck.join()) && 
                Boolean.TRUE.equals(riskCheck.join())) {
                
                // 串行执行：扣库存→创建订单→发送通知
                return deductStock(request)
                    .thenCompose(r -> saveOrder(request))
                    .thenCompose(order -> sendNotification(order));
            }
            throw new BusinessException("校验失败");
        })
        .handle((result, ex) -> {
            if (ex != null) {
                return OrderResult.fail(ex.getMessage());
            }
            return OrderResult.success(result);
        });
}

六、最佳实践总结

• 线程池隔离：IO密集型与CPU密集型任务分离
• 异常处理：使用handle统一处理异常
• 监控指标：Micrometer监控线程池状态
• 资源释放：finally中关闭线程池
• 调试技巧：设置线程名称便于日志追踪

// 监控线程池示例
new ThreadPoolExecutor(
    // ...其他参数
    new ThreadFactoryBuilder()
        .setNameFormat("order-pool-%d")
        .setUncaughtExceptionHandler((t, e) -> 
            log.error("线程{}异常: {}", t.getName(), e.getMessage()))
        .build()
);