Java中的异步操作CompletableFuture示例详解

//最简单的异步调用，默认使用 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：创建订单（有返回值）
    .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：发送通知（纯副作用操作）
    .thenRunAsync(() -> {
        notificationService.sendOrderCreated();
    }, notificationExecutor);

// 场景：用户详情页需要聚合多个服务的数据
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()
            );
        });
}

// 健壮的数据处理管道
CompletableFuture<Report> reportFuture = CompletableFuture
    .supplyAsync(() -> dataFetcher.fetchData(), dataExecutor)
    // exceptionally异常时提供降级值
    .exceptionally(ex -> {
        log.warn("数据获取失败，使用缓存", ex);
        return cacheService.getCachedData();
    })
    // 对数据做处理，同时捕获处理中的异常
    .thenApplyAsync(data -> {
        try {
            return dataProcessor.process(data);
        } catch (ProcessingException e) {
            throw new CompletionException("处理失败", e);
        }
    }, processExecutor)
    // handle统一处理成功和失败
    .handle((processedData, ex) -> {
        if (ex != null) {
            // 失败路径
            metrics.recordFailure(ex);
            return Report.errorReport("系统繁忙，请稍后重试");
        } else {
            // 成功路径
            return Report.successReport(processedData);
        }
    })
    // whenComplete无论成功失败都执行（类似finally）
    .whenComplete((report, ex) -> {
        // 资源清理、日志记录等
        cleanResources();
        log.info("报告生成完成，状态：{}", 
            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密集型：核心数+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密集型：可设置较大线程数
    @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"));
    }
}