CompletableFuture

CompletableFuture 是 Java 8 引入的一个非常重要的类，它是 Future 的增强版本，提供了异步编程的支持。通过它，你可以更方便地进行并发操作、处理回调、链式任务等。以下是一些 CompletableFuture 的常见用法和相关示例。

1. 创建一个基本的 CompletableFuture
你可以通过 CompletableFuture.supplyAsync() 或 CompletableFuture.runAsync() 来启动异步任务。

supplyAsync 用于有返回值的异步操作。
runAsync 用于没有返回值的异步操作。
示例：简单的异步计算
java
import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        // 使用供给型方法，执行异步任务并返回一个结果
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            // 模拟耗时操作
            try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
            return 42;  // 返回计算结果
        });

        // 阻塞直到结果可用并输出
        future.thenAccept(result -> System.out.println("结果是: " + result));
    }
}
在这个例子中，supplyAsync 会在一个新的线程中异步执行计算任务，thenAccept 会在任务完成后处理结果。

2. 使用 thenApply() 进行结果转换
thenApply() 用于对 CompletableFuture 的结果进行转换，它接收一个 Function 作为参数，并返回另一个 CompletableFuture。

示例：使用 thenApply 转换返回结果
java
import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            return 42;
        });

        CompletableFuture<String> transformedFuture = future.thenApply(result -> {
            return "结果是: " + result;
        });

        transformedFuture.thenAccept(System.out::println);
    }
}
3. 使用 thenCombine() 合并两个异步任务的结果
thenCombine() 用于合并两个独立的异步任务的结果，通常用于处理并发操作后需要合并的情况。

示例：合并两个异步任务的结果
java
import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            return 10;
        });

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            return 20;
        });

        CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (result1, result2) -> {
            return result1 + result2;  // 合并两个结果
        });

        combinedFuture.thenAccept(result -> System.out.println("合并结果: " + result));
    }
}
4. 使用 thenCompose() 进行依赖任务的串行执行
thenCompose() 用于将一个异步操作的结果作为下一个异步操作的输入，通常用于当第二个任务依赖于第一个任务的结果时。

示例：串行执行两个任务
java
import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            return 42;
        });

        CompletableFuture<String> chainedFuture = future.thenCompose(result -> {
            return CompletableFuture.supplyAsync(() -> "计算结果是: " + result);
        });

        chainedFuture.thenAccept(System.out::println);
    }
}
在这个例子中，thenCompose 会将第一个任务的结果传递给第二个任务，并等待第二个任务完成。

5. 异常处理：exceptionally() 和 handle()
在异步计算中可能会发生异常，CompletableFuture 提供了几种方式来处理这些异常：

exceptionally()：当异步操作抛出异常时，提供一个备用结果。
handle()：不仅能处理异常，还能处理正常结果。
示例：使用 exceptionally() 处理异常
java
import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            if (true) {
                throw new RuntimeException("模拟异常");
            }
            return 42;
        });

        future.exceptionally(ex -> {
            System.out.println("发生异常: " + ex.getMessage());
            return 0;  // 返回备用结果
        }).thenAccept(result -> System.out.println("结果是: " + result));
    }
}
示例：使用 handle() 处理异常
java
import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            if (true) {
                throw new RuntimeException("模拟异常");
            }
            return 42;
        });

        future.handle((result, ex) -> {
            if (ex != null) {
                System.out.println("发生异常: " + ex.getMessage());
                return 0;  // 返回备用结果
            }
            return result;
        }).thenAccept(result -> System.out.println("结果是: " + result));
    }
}
6. 等待所有任务完成：allOf() 和 anyOf()
allOf() 用于等待多个 CompletableFuture 都完成。
anyOf() 用于等待多个 CompletableFuture 中的任何一个完成。
示例：使用 allOf() 等待多个任务完成
java
import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            return 10;
        });

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            return 20;
        });

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

        allOfFuture.thenRun(() -> {
            System.out.println("所有任务都完成了");
            try {
                System.out.println("future1 的结果: " + future1.get());
                System.out.println("future2 的结果: " + future2.get());
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }
}
示例：使用 anyOf() 等待任意任务完成
java
import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            return 10;
        });

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            return 20;
        });

        CompletableFuture<Object> anyOfFuture = CompletableFuture.anyOf(future1, future2);

        anyOfFuture.thenAccept(result -> System.out.println("第一个完成的任务结果是: " + result));
    }
}
7. 组合多个 CompletableFuture 任务：thenCombine(), thenCompose(), allOf(), anyOf()
thenCombine(): 两个 CompletableFuture 结果合并。
thenCompose(): 串行化多个异步操作。
allOf(): 等待多个 CompletableFuture 全部完成。
anyOf(): 等待多个 CompletableFuture 中任意一个完成。
总结
CompletableFuture 提供了强大的功能来实现异步任务、链式调用、并发处理、异常处理等。通过使用合适的 API，可以轻松实现复杂的异步操作。

希望这些示例能够帮助你理解 CompletableFuture 的基本使用方法。如果你有任何问题或需要更多的帮助，随时问我！