✅如何在 Java 中实现高效的异步编程？如何避免回调地狱？
典型回答
（这个不算是面试题了，面试很少这么问，大家知道下什么是callback hell即可，但是内容大家可以看下，对于在工作中的使用还是有帮助的。）
在 Java 中实现高效的异步编程通常依赖于 异步执行模型，例如通过 **CompletableFuture**、**ExecutorService**、**Future** 等方式，来处理异步任务。
同时，避免 回调地狱是实现异步编程时的一大挑战，特别是在多个异步操作需要顺序执行并且它们之间可能会相互依赖的情况下。
回调地狱(callback hell)是指在使用传统回调方法时，如果有多个依赖关系的异步任务，代码会变得难以阅读和维护。
ExecutorService
ExecutorService 是 Java 提供的一个高效的线程池管理工具，它支持异步任务的提交和执行。通过 submit() 方法提交任务，返回 Future 对象可以用于获取任务的执行结果。
import java.util.concurrent.*;
public class ExecutorServiceExample {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = Executors.newFixedThreadPool(2);
// 提交一个异步任务
Future<Integer> future = executorService.submit(() -> {
// 模拟一些异步操作
Thread.sleep(1000);
return 42; // 返回计算结果
});
// 获取任务结果，阻塞直到任务完成
Integer result = future.get(); // result = 42
System.out.println("异步任务的结果: " + result);
executorService.shutdown();
}
}CompletableFuture
CompletableFuture 是 Java 8 引入的一个功能强大的工具，用于支持异步计算和组合多个异步任务。与传统的 Future 不同，CompletableFuture 不仅可以异步执行任务，还可以通过链式调用的方式进行任务的组合与控制。
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) throws Exception {
// 异步执行任务
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
// 模拟一个异步计算
System.out.println("异步任务开始执行");
return 42;
});
// 使用 thenApply 进行链式调用
CompletableFuture<String> resultFuture = future.thenApply(result -> {
// 在原任务完成后处理结果
System.out.println("处理异步结果");
return "结果是: " + result;
});
// 获取最终结果
System.out.println(resultFuture.get()); // 输出: 结果是: 42
}
}异步的组合与并行执行
CompletableFuture 支持多个异步任务的并行执行，使用 thenCombine()、allOf() 和 anyOf() 等方法，可以组合多个任务的结果，避免回调地狱。
**thenCombine()**：并行执行两个任务，合并它们的结果。**allOf()**：等待所有异步任务完成，然后执行后续操作。**anyOf()**：等待第一个异步任务完成，执行后续操作。
import java.util.concurrent.CompletableFuture;
public class CompletableFutureCombineExample {
public static void main(String[] args) throws Exception {
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);
// 使用 thenCombine 来并行执行两个任务并合并结果
CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + result2);
System.out.println("合并结果: " + combinedFuture.get()); // 输出: 合并结果: 30
}
}处理异常与超时
CompletableFuture 提供了方法来处理任务中的异常或超时问题，使用 exceptionally() 或 handle() 方法来定义异常处理的逻辑。
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
public class CompletableFutureExceptionExample {
public static void main(String[] args) throws Exception {
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));
}
}避免回调地狱
为了避免回调地狱，通常有以下几种解决方案：
使用 CompletableFuture 的链式操作
通过 CompletableFuture 的 thenApply、thenAccept、thenCombine 等方法，可以避免层层嵌套的回调结构。每个异步操作都返回一个新的 CompletableFuture，让后续的操作能够依次执行。
import java.util.concurrent.CompletableFuture;
public class CallbackHellExample {
public static void main(String[] args) throws Exception {
// 模拟异步任务
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
return 10; // 第一个任务
}).thenApplyAsync(result -> {
return result + 5; // 第二个任务
}).thenApplyAsync(result -> {
return result * 2; // 第三个任务
});
// 获取最终结果
System.out.println("最终结果: " + future.get()); // 输出: 最终结果: 30
}
}使用 whenComplete 或 handle 方法来统一处理任务的结果和异常
whenComplete 和 handle 方法允许你在任务完成时进行统一的处理，包括处理正常结果或异常。这样可以避免在每个回调中重复处理结果和异常。
import java.util.concurrent.CompletableFuture;
public class HandleExample {
public static void main(String[] args) throws Exception {
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 10);
// 使用 handle() 来处理结果和异常
future.handle((result, ex) -> {
if (ex != null) {
System.out.println("处理异常: " + ex.getMessage());
return 0; // 异常时返回默认值
}
return result * 2; // 正常结果
}).thenAccept(result -> System.out.println("最终结果: " + result));
}
}使用 allOf() 和 anyOf() 合并多个异步任务
对于多个并行执行的任务，如果需要等待所有任务完成后再进行处理，可以使用 allOf() 方法。这样可以避免在每个任务之间嵌套回调。
import java.util.concurrent.CompletableFuture;
public class AllOfExample {
public static void main(String[] args) throws Exception {
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);
// 使用 allOf 等待多个任务完成
CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2);
allOf.thenRun(() -> {
try {
// 获取结果
System.out.println("任务1的结果: " + future1.get());
System.out.println("任务2的结果: " + future2.get());
} catch (Exception e) {
e.printStackTrace();
}
}).join();
}
}使用 ExecutorService 配合 CompletableFuture 进行并发执行
通过 ExecutorService 提供的线程池和 CompletableFuture，可以有效地管理多个并发的异步任务，避免回调地狱并且能够进行异步任务的组合。
import java.util.concurrent.*;
public class ExecutorServiceCompletableFuture {
public static void main(String[] args) throws Exception {
ExecutorService executorService = Executors.newFixedThreadPool(4);
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
return 5;
}, executorService);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
return 10;
}, executorService);
// 合并两个异步结果
CompletableFuture<Integer> combined = future1.thenCombine(future2, Integer::sum);
System.out.println("两个任务的结果: " + combined.get()); // 输出: 15
executorService.shutdown();
}
}