高并发编程/一张图精通CompletableFuture整体执行流程与设计(高手篇)

4.10. 超时和取消

• CompletableFuture<T> orTimeout(long timeout, TimeUnit unit): 如果在给定的超时时间内没有完成，则异常完成。
• CompletableFuture<T> completeOnTimeout(T value, long timeout, TimeUnit unit): 如果在给定的超时时间内没有完成，则以给定的值完成。
• boolean cancel(boolean mayInterruptIfRunning): 尝试取消执行。

4.11. 结果获取

• T get(): 等待任务完成并获取结果。
• T join(): 等待任务完成并获取结果。
• T getNow(T valueIfAbsent): 获取当前结果，如果未完成则返回给定的值。
• T getThenApplyAsync(Function<? super T, ? extends U> fn): 获取结果并异步应用函数。

5、CompletableFuture 应用案例

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

public class ComprehensiveCompletableFutureExample {

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(4);

        // 4.2. 创建和启动异步计算
        CompletableFuture<Boolean> inventoryCheckFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("检查库存...");
            return true; // 假设库存充足
        }, executor);

        // 4.4. 正常完成时的转换
        CompletableFuture<String> orderCreationFuture = inventoryCheckFuture.thenApplyAsync(
                Boolean::booleanValue,
                ordered -> "ORDER-" + ordered,
                executor
        );

        // 4.5. 组合 CompletableFuture
        CompletableFuture<String> paymentProcessingFuture = orderCreationFuture.thenComposeAsync(
                order -> CompletableFuture.supplyAsync(() -> {
                    System.out.println("处理支付...");
                    return "PAYMENT-" + order;
                }),
                executor
        );

        // 4.6. 异常处理
        CompletableFuture<String> exceptionHandledFuture = paymentProcessingFuture.exceptionally(
                ex -> "EXCEPTION-" + ex.getMessage()
        );

        // 4.7. 完成时的回调（无论成功或失败）
        CompletableFuture<String> finalResultFuture = exceptionHandledFuture.handle((result, ex) -> {
            if (ex == null) {
                System.out.println("订单处理成功: " + result);
                return result;
            } else {
                System.out.println("订单处理失败: " + ex.getMessage());
                return "FAILURE-" + ex.getMessage();
            }
        });

        // 4.8. 等待其他 CompletableFuture
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(
                inventoryCheckFuture,
                orderCreationFuture,
                paymentProcessingFuture,
                exceptionHandledFuture,
                finalResultFuture
        );

        // 4.9. 任意一个或全部完成
        CompletableFuture<Object> anyOfFutures = CompletableFuture.anyOf(
                inventoryCheckFuture,
                orderCreationFuture,
                paymentProcessingFuture,
                exceptionHandledFuture,
                finalResultFuture
        );

        // 4.10. 超时和取消
        CompletableFuture<String> timeoutFuture = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "TIMEOUT";
        }).orTimeout(1, TimeUnit.SECONDS);

        // 4.11. 结果获取
        finalResultFuture.thenAccept(result -> {
            System.out.println("最终结果: " + result);
        });

        timeoutFuture.exceptionally(ex -> {
            System.out.println("超时异常: " + ex.getMessage());
            return null;
        });

        // 等待所有任务完成
        allFutures.join();

        // 关闭线程池
        executor.shutdown();
    }
}

代码解释：

1. 创建和启动异步计算：使用supplyAsync检查库存。
2. 正常完成时的转换：使用thenApplyAsync创建订单。
3. 组合CompletableFuture：使用thenComposeAsync处理支付。
4. 异常处理：使用exceptionally处理支付过程中的异常。
5. 完成时的回调（无论成功或失败） ：使用handle处理最终结果。
6. 等待其他CompletableFuture：使用allOf等待所有任务完成。
7. 任意一个或全部完成：使用anyOf等待任一任务完成。
8. 超时和取消：使用orTimeout设置超时。
9. 结果获取：使用thenAccept打印最终结果。