Java CompletableFuture之异步执行、链式调用、组合多个Future、异常处理和超时控制等详解

目录

• Java ComputableFuture 代码示例
• 1. 基本用法
• 2. 链式调用
• 3. 组合多个 Future
• 4. 异常处理
• 5. 并行执行多个任务
• 6. 超时处理（Java 9+）
• 总结

Java ComputableFuture 代码示例

CompletableFuture 是 Java 8 引入的一个强大的异步编程工具，它实现了 Future 接口并提供了更丰富的功能。

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

1. 基本用法

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

public class CompletableFutureBasicExample {
    public static void main(String[] args) {
        // 创建一个CompletableFuture并异步执行任务
        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 androidmain(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);
xJIFUrUxFA        }).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. 并行执行多个任务

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";
        });
    php    
        // 等待所有任务完成
        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.SECO编程客栈NDS.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 的主要功能，包括异步执行、链式调用、组合多个 Future、异常处理和超时控制等。CompletableFuture 是 Java 并发编程中非常强大的工具，可以大大简化异步编程的复杂性。

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程客栈(www.devze.com)。