Java中经常会遇到需要进行异步操作的场景。对于这种情况，Java 8引入了CompletableFuture类，它为我们提供了丰富的异步编程工具，使异步编程更加简便易行。其中，thenCompose和thenCombine是CompletableFuture类中常用的两种组合异步操作方法。
一、thenCompose的使用
thenCompose方法用于将一个CompletableFuture实例转化为另一个CompletableFuture实例。具体来说，它接收一个Function参数，该参数将前一个CompletableFuture返回的结果作为输入，并返回一个新的CompletableFuture对象。下面是一个示例：
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
// 模拟计算耗时
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 10;
});
CompletableFuture<Integer> result = future.thenCompose(value -> CompletableFuture.supplyAsync(() -> value * 2));
result.whenComplete((res, ex) -> {
if (ex != null) {
ex.printStackTrace();
} else {
System.out.println(res);
}
});在上述代码中，首先我们创建了一个CompletableFuture实例，它会在另一个线程中模拟计算耗时。接着，我们使用thenCompose方法将其转化为一个新的CompletableFuture实例，该实例会将前一个CompletableFuture返回的结果乘以2。最后，我们使用whenComplete方法来输出结果或错误信息。
二、thenCombine的使用
thenCombine方法用于将两个CompletableFuture实例合并为一个。具体来说，它接收另一个CompletableFuture实例和一个BiFunction参数，该参数将两个CompletableFuture返回的结果作为输入，并返回一个新的CompletableFuture对象。下面是一个示例：
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
// 模拟计算耗时
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 10;
});
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
// 模拟计算耗时
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 5;
});
CompletableFuture<Integer> result = future1.thenCombine(future2, (value1, value2) -> value1 + value2);
result.whenComplete((res, ex) -> {
if (ex != null) {
ex.printStackTrace();
} else {
System.out.println(res);
}
});在上述代码中，我们创建了两个CompletableFuture实例，它们分别模拟了两个计算任务的执行。接着，我们使用thenCombine方法将这两个CompletableFuture实例合并成一个新的实例，该实例将前两个CompletableFuture返回的结果相加。最后，我们使用whenComplete方法来输出结果或错误信息。
三、使用thenCompose和thenCombine实现复杂异步操作
前面我们已经介绍了thenCompose和thenCombine方法的使用，它们都是非常有用的异步操作方法。实际上，我们还可以使用它们来实现更加复杂的异步操作，例如对多个计算结果的聚合操作。
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
// 模拟计算耗时
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 10;
});
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
// 模拟计算耗时
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 5;
});
CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
// 模拟计算耗时
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 20;
});
CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(future1, future2, future3);
CompletableFuture<Integer> result = combinedFuture.thenCompose(
voidResult -> CompletableFuture.supplyAsync(() -> {
int sum = future1.join() + future2.join() + future3.join();
return sum;
}));
result.whenComplete((res, ex) -> {
if (ex != null) {
ex.printStackTrace();
} else {
System.out.println(res);
}
});在上述代码中，我们创建了三个Completable
.........................................................