public class CompletionServiceDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 創(chuàng)建線程池和CompletionService
        ExecutorService executor = Executors.newFixedThreadPool(3);
        CompletionService<String> completionService = new ExecutorCompletionService<>(executor);

        // 提交3個(gè)任務(wù)（模擬不同接口調(diào)用，執(zhí)行時(shí)間不同）
        completionService.submit(() -> {
            Thread.sleep(3000); // 模擬耗時(shí)3秒
            return"接口A結(jié)果";
        });
        completionService.submit(() -> {
            Thread.sleep(1000); // 模擬耗時(shí)1秒
            return"接口B結(jié)果";
        });
        completionService.submit(() -> {
            Thread.sleep(2000); // 模擬耗時(shí)2秒
            return"接口C結(jié)果";
        });

        // 按完成順序獲取結(jié)果（預(yù)期順序：B→C→A）
        for (int i = 0; i < 3; i++) {
            Future<String> future = completionService.take(); // 阻塞等待下一個(gè)完成的任務(wù)
            System.out.println("處理結(jié)果：" + future.get());
        }

        executor.shutdown();
    }
}

public class CompletableFutureDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 接口A：返回用戶ID
        CompletableFuture<String> futureA = CompletableFuture.supplyAsync(() -> {
            try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
            return"user123";
        });

        // 接口B：依賴A的結(jié)果，返回用戶信息
        CompletableFuture<String> futureB = futureA.thenCompose(userId -> 
            CompletableFuture.supplyAsync(() -> {
                try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); }
                return"用戶信息：" + userId;
            })
        );

        // 接口C：獨(dú)立任務(wù)，返回用戶積分
        CompletableFuture<Integer> futureC = CompletableFuture.supplyAsync(() -> {
            try { Thread.sleep(800); } catch (InterruptedException e) { e.printStackTrace(); }
            return 1000;
        });

        // 合并B和C的結(jié)果
        CompletableFuture<String> combined = futureB.thenCombine(futureC, 
            (userInfo, score) -> userInfo + "，積分：" + score
        );

        System.out.println(combined.get()); // 阻塞獲取最終結(jié)果
    }
}

// 任務(wù)結(jié)果封裝類
class TaskResult {
    private boolean success;
    private String message;
    private String taskName;

    public TaskResult(boolean success, String message, String taskName) {
        this.success = success;
        this.message = message;
        this.taskName = taskName;
    }

    public boolean isSuccess() {
        return success;
    }

    public String getMessage() {
        return message;
    }

    public String getTaskName() {
        return taskName;
    }
}

// 模擬業(yè)務(wù)任務(wù)
class BusinessTask implements Callable<TaskResult> {
    private String taskName;
    private int executionTime; // 執(zhí)行時(shí)間(毫秒)
    private boolean shouldSucceed; // 是否應(yīng)該成功

    public BusinessTask(String taskName, int executionTime, boolean shouldSucceed) {
        this.taskName = taskName;
        this.executionTime = executionTime;
        this.shouldSucceed = shouldSucceed;
    }

    @Override
    public TaskResult call() throws Exception {
        System.out.println("任務(wù) " + taskName + " 開(kāi)始執(zhí)行");
        // 模擬任務(wù)執(zhí)行時(shí)間
        Thread.sleep(executionTime);
        
        if (shouldSucceed) {
            return new TaskResult(true, taskName + " 執(zhí)行成功", taskName);
        } else {
            throw new Exception(taskName + " 執(zhí)行失敗");
        }
    }
}

public class ConcurrentTaskDemo {
    public static void main(String[] args) {
        // 創(chuàng)建線程池
        ExecutorService executor = Executors.newFixedThreadPool(3);
        CompletionService<TaskResult> completionService = new ExecutorCompletionService<>(executor);
        
        // 存儲(chǔ)所有提交的任務(wù)，用于后續(xù)可能的取消操作
        List<Future<TaskResult>> futures = new ArrayList<>();
        
        try {
            // 提交三個(gè)任務(wù)
            futures.add(completionService.submit(new BusinessTask("支付接口A", 1000, false)));
            futures.add(completionService.submit(new BusinessTask("支付接口B", 2000, true)));
            futures.add(completionService.submit(new BusinessTask("支付接口C", 3000, false)));
            
            // 等待任務(wù)完成，只要有一個(gè)成功就返回
            TaskResult successResult = null;
            int taskCount = futures.size();
            
            for (int i = 0; i < taskCount; i++) {
                try {
                    // 獲取已完成的任務(wù)結(jié)果，設(shè)置超時(shí)時(shí)間
                    Future<TaskResult> future = completionService.poll(5, TimeUnit.SECONDS);
                    if (future == null) {
                        System.out.println("獲取任務(wù)結(jié)果超時(shí)");
                        continue;
                    }
                    
                    // 如果沒(méi)有異常拋出，說(shuō)明任務(wù)成功
                    TaskResult result = future.get();
                    successResult = result;
                    break; // 只要有一個(gè)成功就跳出循環(huán)
                    
                } catch (ExecutionException e) {
                    // 任務(wù)執(zhí)行失敗，繼續(xù)等待其他任務(wù)
                    System.out.println("任務(wù)執(zhí)行失敗: " + e.getCause().getMessage());
                } catch (TimeoutException e) {
                    System.out.println("等待任務(wù)完成超時(shí)");
                }
            }
            
            // 處理最終結(jié)果
            if (successResult != null) {
                System.out.println("整體執(zhí)行成功: " + successResult.getMessage());
                // 取消其他可能還在執(zhí)行的任務(wù)
                cancelRemainingTasks(futures);
            } else {
                System.out.println("所有任務(wù)都執(zhí)行失敗");
            }
            
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println("線程被中斷: " + e.getMessage());
        } finally {
            // 關(guān)閉線程池
            executor.shutdown();
        }
    }
    
    // 取消所有未完成的任務(wù)
    private static void cancelRemainingTasks(List<Future<TaskResult>> futures) {
        for (Future<TaskResult> future : futures) {
            if (!future.isDone()) {
                future.cancel(true);
                System.out.println("取消未完成的任務(wù)");
            }
        }
    }
}