Java CompletableFuture之異步執(zhí)行、鏈式調用、組合多個Future、異常處理和超時控制等詳解

更新時間：2025年05月29日 10:02:14 作者：學亮編程手記

這篇文章主要介紹了Java CompletableFuture之異步執(zhí)行、鏈式調用、組合多個Future、異常處理和超時控制等用法,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教

Java ComputableFuture 代碼示例

CompletableFuture 是 Java 8 引入的一個強大的異步編程工具，它實現(xiàn)了 Future 接口并提供了更豐富的功能。

以下是一些常見的 CompletableFuture 使用示例：

1. 基本用法

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

public class CompletableFutureBasicExample {
    public static void main(String[] args) {
        // 創(chuàng)建一個CompletableFuture并異步執(zhí)行任務
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000); // 模擬耗時操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello, CompletableFuture!";
        });
        
        // 注冊完成時的回調
        future.thenAccept(result -> System.out.println("Result: " + result));
        
        // 阻塞等待結果
        try {
            String result = future.get();
            System.out.println("Main thread got: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

2. 鏈式調用

import java.util.concurrent.CompletableFuture;

public class CompletableFutureChainExample {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            // 第一個異步任務
            System.out.println("Task 1 running in thread: " + Thread.currentThread().getName());
            return "Hello";
        }).thenApplyAsync(result -> {
            // 第二個異步任務，接收上一個任務的結果
            System.out.println("Task 2 running in thread: " + Thread.currentThread().getName());
            return result + " World";
        }).thenAcceptAsync(result -> {
            // 第三個異步任務，消費最終結果
            System.out.println("Task 3 running in thread: " + Thread.currentThread().getName());
            System.out.println("Final result: " + result);
        }).join(); // 等待所有任務完成
    }
}

3. 組合多個 Future

import java.util.concurrent.CompletableFuture;

public class CompletableFutureCombineExample {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");
        
        // 合并兩個Future的結果
        CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (s1, s2) -> s1 + " " + s2);
        
        combinedFuture.thenAccept(System.out::println).join();
    }
}

4. 異常處理

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExceptionHandling {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            if (Math.random() > 0.5) {
                throw new RuntimeException("Something went wrong!");
            }
            return "Success";
        }).exceptionally(ex -> {
            System.out.println("Exception occurred: " + ex.getMessage());
            return "Recovered from exception";
        }).thenAccept(System.out::println).join();
    }
}

5. 并行執(zhí)行多個任務

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public class CompletableFutureAllOfExample {
    public static void main(String[] args) {
        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            sleep(1);
            return "Task 1";
        });
        
        CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
            sleep(2);
            return "Task 2";
        });
        
        CompletableFuture<String> task3 = CompletableFuture.supplyAsync(() -> {
            sleep(3);
            return "Task 3";
        });
        
        // 等待所有任務完成
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(task1, task2, task3);
        
        // 獲取所有任務的結果
        CompletableFuture<String> combinedFuture = allFutures.thenApply(v -> {
            String result1 = task1.join();
            String result2 = task2.join();
            String result3 = task3.join();
            return result1 + ", " + result2 + ", " + result3;
        });
        
        System.out.println("Combined result: " + combinedFuture.join());
    }
    
    private static void sleep(int seconds) {
        try {
            TimeUnit.SECONDS.sleep(seconds);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

6. 超時處理（Java 9+）

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CompletableFutureTimeoutExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000); // 模擬耗時操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Result";
        });
        
        // 設置超時時間為1秒
        CompletableFuture<String> timeoutFuture = future.orTimeout(1, TimeUnit.SECONDS);
        
        timeoutFuture.whenComplete((result, ex) -> {
            if (ex != null) {
                System.out.println("Exception: " + ex.getClass().getName());
                if (ex.getCause() instanceof TimeoutException) {
                    System.out.println("Task timed out");
                }
            } else {
                System.out.println("Result: " + result);
            }
        }).join();
    }
}

這些示例展示了 CompletableFuture 的主要功能，包括異步執(zhí)行、鏈式調用、組合多個 Future、異常處理和超時控制等。CompletableFuture 是 Java 并發(fā)編程中非常強大的工具，可以大大簡化異步編程的復雜性。