import java.util.concurrent.*;
import java.util.Arrays;

public class TaskOrchestrator {
    public static void main(String[] args) {
        // 創(chuàng)建一個線程池來執(zhí)行任務(wù)
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 定義任務(wù)一
        Future<String> taskOneResult = executor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(2000); // 模擬耗時操作
                return "Task One Result";
            }
        });

        // 定義任務(wù)二，依賴任務(wù)一
        Future<String> taskTwoResult = executor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                String result = taskOneResult.get(); // 阻塞等待任務(wù)一完成
                Thread.sleep(1000); // 模擬耗時操作
                return "Task Two Result, got: " + result;
            }
        });

        // 定義任務(wù)三
        Future<String> taskThreeResult = executor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(1500); // 模擬耗時操作
                return "Task Three Result";
            }
        });

        // 定義任務(wù)四，依賴任務(wù)二和任務(wù)三
        Future<String> taskFourResult = executor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                String taskTwoOutput = taskTwoResult.get(); // 阻塞等待任務(wù)二完成
                String taskThreeOutput = taskThreeResult.get(); // 阻塞等待任務(wù)三完成
                Thread.sleep(500); // 模擬耗時操作
                return "Task Four Result, got: " + taskTwoOutput + " and " + taskThreeOutput;
            }
        });

        // 打印最終結(jié)果
        try {
            System.out.println("Final Result: " + taskFourResult.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {

    public static void main(String[] args) {
        // 任務(wù)一：返回 "Task 1 result"
        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            try {
                // 模擬耗時操作
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
            return "Task 1 result";
        });
        // 任務(wù)二：依賴任務(wù)一，返回 "Task 2 result" + 任務(wù)一的結(jié)果
        CompletableFuture<String> task2 = task1.handle((result1, throwable) -> {
            try {
                // 模擬耗時操作
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
            return "Task 2 result " + result1;
        });
        // 任務(wù)三：和任務(wù)一、任務(wù)二并行執(zhí)行，返回 "Task 3 result"
        CompletableFuture<String> task3 = CompletableFuture.supplyAsync(() -> {
            try {
                // 模擬耗時操作
                Thread.sleep(800); // 任務(wù)三可能比任務(wù)二先完成
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
            return "Task 3 result";
        });
        // 任務(wù)四：依賴任務(wù)二和任務(wù)三，等待它們都完成后執(zhí)行，返回 "Task 4 result" + 任務(wù)二和任務(wù)三的結(jié)果
        CompletableFuture<String> task4 = CompletableFuture.allOf(task2, task3).handle((res, throwable) -> {
            try {
                // 這里不需要顯式等待，因為 allOf 已經(jīng)保證了它們完成
                return "Task 4 result with " + task2.get() + " and " + task3.get();
            } catch (InterruptedException | ExecutionException e) {
                throw new RuntimeException(e);
            }
        });
        // 獲取任務(wù)四的結(jié)果并打印
        String finalResult = task4.join();
        System.out.println(finalResult);
    }
}