public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        System.out.println(new Date());
        Future<String> future1 = executorService.submit(() -> {
            Thread.sleep(5000);
            return new Date() + ":" + "thread1 result";
        });
        Future<String> future2 = executorService.submit(() -> {
            Thread.sleep(3000);
            return new Date() + ":" + "thread2 result";
        });
        try {
            System.out.println(future1.get());
            System.out.println(future2.get());
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 故意拋出一個異常
            if (System.currentTimeMillis() % 2 == 0) {
                throw new RuntimeException("Exception occurred!");
            }
            return "Result";
        }, executorService);

        future = future.exceptionally(ex -> {
            // 對異常進行處理，并提供一個異常時的結(jié)果
            return "Default Value";
        });

        try {
            System.out.println(future.get()); // 輸出 "Default Value"
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

        future = future.handle((result, ex) -> {
            if (ex != null) {
                return "Default Value";
            }
            return result;
        });
        try {
            System.out.println(future.get()); // 輸出 "Default Value"
        } catch (Exception e) {
            e.printStackTrace();
        }

public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                // 隨機sleep 0-2s
                Thread.sleep(ThreadLocalRandom.current().nextInt(2000));
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "Result";
        }, executorService);
        CompletableFuture<String> finalFuture = future;
        // 1s后手動完成
        executorService.submit(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 手動地完成這個 CompletableFuture，并設(shè)置計算結(jié)果
            finalFuture.complete("Default Value");
        });

        try {
            System.out.println(future.get()); // 概率性輸出 "Default Value"
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    return "Hello";
});

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    return "World!";
});

CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (s1, s2) -> {
    return s1 + ", " + s2;
});

try {
    String result = combinedFuture.get();
    System.out.println(result); // 輸出 "Hello, World!"
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    return "Hello";
});

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    return "World!";
});

CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2);

// 當(dāng)所有的 CompletableFuture 都完成時，獲取結(jié)果
allFutures.thenRun(() -> {
    try {
        String result1 = future1.get();
        String result2 = future2.get();
        System.out.println(result1 + ", " + result2); // 輸出 "Hello, World!"
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
});

public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 異步任務(wù)
            return "Hello, World!";
        });

        future.thenApply(result -> {
            // 當(dāng) future 完成時，這個回調(diào)會被調(diào)用。
            // result 參數(shù)是 future 的結(jié)果。
            // 這個回調(diào)的結(jié)果會被包裝成一個新的 CompletableFuture。
            return result.length();
        }).thenAccept(length -> {
            // 當(dāng)前面的 CompletableFuture 完成時，這個回調(diào)會被調(diào)用。
            // length 參數(shù)是前面 CompletableFuture 的結(jié)果。
            // 這個回調(diào)沒有返回值。
            System.out.println(length); // 輸出 "Hello, World!" 的長度
        }).thenRun(() -> {
            // 當(dāng)前面的 CompletableFuture 完成時，這個回調(diào)會被調(diào)用。
            // 這個回調(diào)沒有輸入?yún)?shù)，也沒有返回值。
            System.out.println("Done");
        });
    }