面试的时候问你，分得清什么时候使用FutureTask和CompletableFuture吗

// 1. 定义任务（实现 Callable）
Callable<Integer> calculateTask = () -> {
    // 模拟耗时计算
    Thread.sleep(3000);
    return 1000; // 任务结果
};

// 2. 包装为 FutureTask
FutureTask<Integer> futureTask = new FutureTask<>(calculateTask);

// 3. 提交到线程池执行
ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(futureTask);

// 4. 主线程做其他事（非阻塞）
System.out.println("主线程处理其他逻辑...");

// 5. 后续需要结果时，阻塞获取（或用 isDone() 轮询）
try {
    Integer result = futureTask.get(); // 阻塞直到任务完成
    System.out.println("任务结果：" + result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

executor.shutdown();

// 自定义线程池（推荐，避免使用默认 ForkJoinPool）
ExecutorService userPool = Executors.newFixedThreadPool(3);
ExecutorService msgPool = Executors.newSingleThreadExecutor();

// 任务A：保存用户信息（返回用户ID）
CompletableFuture<Long> saveUserFuture = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务A：保存用户信息");
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    return 1001L; // 用户ID
}, userPool);

// 任务B：发送欢迎短信（依赖任务A的用户ID，返回短信发送状态）
CompletableFuture<Boolean> sendMsgFuture = saveUserFuture.thenApplyAsync(userId -> {
    System.out.println("任务B：给用户 " + userId + " 发送短信");
    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    return true; // 短信发送成功
}, msgPool);

// 任务C：记录操作日志（依赖任务B的短信状态，无返回值）
CompletableFuture<Void> logFuture = sendMsgFuture.thenAcceptAsync(success -> {
    System.out.println("任务C：记录短信发送日志，状态：" + success);
}, userPool);

// 等待所有任务完成（可选，若主线程需等待流程结束）
logFuture.join();

// 关闭线程池
userPool.shutdown();
msgPool.shutdown();

// 任务1：获取用户基础信息
CompletableFuture<User> userFuture = CompletableFuture.supplyAsync(() -> userService.getUser(1001));
// 任务2：获取用户订单列表
CompletableFuture<List<Order>> orderFuture = CompletableFuture.supplyAsync(() -> orderService.getOrders(1001));
// 任务3：获取用户优惠券
CompletableFuture<List<Coupon>> couponFuture = CompletableFuture.supplyAsync(() -> couponService.getCoupons(1001));

// 等待所有任务完成（无返回值，仅等待）
CompletableFuture<Void> allFuture = CompletableFuture.allOf(userFuture, orderFuture, couponFuture);

// 后续逻辑需在所有任务完成后执行
allFuture.thenRun(() -> {
    try {
        User user = userFuture.get();
        List<Order> orders = orderFuture.get();
        List<Coupon> coupons = couponFuture.get();
        // 合并数据并返回给前端
        System.out.println("用户信息：" + user + "，订单数：" + orders.size() + "，优惠券数：" + coupons.size());
    } catch (Exception e) {
        e.printStackTrace();
    }
}).join();

// 任务1：调用支付宝支付
CompletableFuture<String> aliPayFuture = CompletableFuture.supplyAsync(() -> aliPayService.pay(100.0));
// 任务2：调用微信支付
CompletableFuture<String> wxPayFuture = CompletableFuture.supplyAsync(() -> wxPayService.pay(100.0));

// 等待任意一个任务完成（返回最先完成的任务结果）
CompletableFuture<Object> anyFuture = CompletableFuture.anyOf(aliPayFuture, wxPayFuture);

// 处理最先完成的结果
anyFuture.thenAccept(result -> {
    System.out.println("支付成功，渠道返回：" + result);
}).join();

// 任务1：生成报表（耗时操作）
CompletableFuture<Report> reportFuture = CompletableFuture.supplyAsync(() -> reportService.generateReport(1001));

// 任务2：报表生成完成后，发送邮件（回调任务）
reportFuture.thenAcceptAsync(report -> {
    System.out.println("报表生成完成，开始发送邮件...");
    emailService.sendEmail(report.getUserId(), "报表已生成", report.getDownloadUrl());
}, emailExecutor);

// 主线程直接返回响应，无需等待报表生成和邮件发送
System.out.println("报表正在生成中，请稍后查看邮件通知...");

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 任务A：模拟执行失败
    int i = 1 / 0;
    return 100;
}).exceptionally(ex -> {
    // 捕获任务A的异常，返回默认值
    System.out.println("任务A执行失败：" + ex.getMessage());
    return 0; // 默认值
}).thenApply(result -> {
    // 任务B：使用任务A的结果（正常结果或默认值）
    return result * 2;
});

System.out.println("最终结果：" + future.join()); // 输出 0

// 推荐：使用自定义线程池
ExecutorService myPool = Executors.newFixedThreadPool(5);
CompletableFuture.supplyAsync(() -> {
    // 任务逻辑
}, myPool);