一、异步编程与 CompletableFuture 简介
在 Java 编程的世界里，同步编程就像是按部就班地排队办事，一件事做完了才能做下一件。而异步编程则像是同时开启多条通道，多个任务可以并行执行，大大提高了程序的效率。CompletableFuture 就是 Java 8 引入的一个强大工具，它为我们实现异步编程提供了便利。
想象一下，你要做一顿丰盛的晚餐，同步编程就像是你先洗菜，洗完菜再切菜，切完菜再炒菜，一步一步来。而异步编程呢，你可以在洗菜的同时让电饭煲煮饭，在切菜的时候让烤箱预热，这样就节省了很多时间。CompletableFuture 就像是一个智能的小助手，帮助你协调这些并行的任务。
二、CompletableFuture 的基本使用
2.1 创建 CompletableFuture
我们先来看一个简单的例子，使用 CompletableFuture.runAsync 方法来执行一个异步任务。
import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
public static void main(String[] args) {
// 创建一个 CompletableFuture 并异步执行任务
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
// 模拟一个耗时任务
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("异步任务执行完成");
});
// 主线程可以继续做其他事情
System.out.println("主线程继续执行");
try {
// 等待异步任务完成
future.get();
} catch (Exception e) {
e.printStackTrace();
}
}
}
在这个例子中，CompletableFuture.runAsync 方法接收一个 Runnable 对象，它会在一个新的线程中异步执行这个任务。主线程不会等待这个任务完成，而是可以继续执行其他操作。最后，我们使用 future.get() 方法来等待异步任务完成。
2.2 带有返回值的 CompletableFuture
如果异步任务需要返回一个结果，我们可以使用 CompletableFuture.supplyAsync 方法。
import java.util.concurrent.CompletableFuture;
public class CompletableFutureWithResult {
public static void main(String[] args) {
// 创建一个带有返回值的 CompletableFuture
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
// 模拟一个耗时任务并返回结果
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "异步任务的结果";
});
try {
// 获取异步任务的结果
String result = future.get();
System.out.println("异步任务的结果是: " + result);
} catch (Exception e) {
e.printStackTrace();
}
}
}
这里，CompletableFuture.supplyAsync 方法接收一个 Supplier 对象，它会在异步线程中执行这个 Supplier 的 get 方法，并返回结果。我们可以使用 future.get() 方法来获取这个结果。
三、CompletableFuture 的组合操作
3.1 顺序执行任务
有时候，我们需要一个任务完成后再执行另一个任务。CompletableFuture 提供了 thenApply 和 thenAccept 等方法来实现顺序执行。
import java.util.concurrent.CompletableFuture;
public class SequentialTasks {
public static void main(String[] args) {
// 第一个异步任务
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "第一个任务的结果";
});
// 第二个任务依赖于第一个任务的结果
CompletableFuture<String> future2 = future1.thenApply(result -> {
System.out.println("接收到第一个任务的结果: " + result);
return result + " 加上第二个任务的处理";
});
try {
// 获取最终结果
String finalResult = future2.get();
System.out.println("最终结果: " + finalResult);
} catch (Exception e) {
e.printStackTrace();
}
}
}
在这个例子中，thenApply 方法接收一个 Function 对象，它会在第一个任务完成后，将第一个任务的结果作为参数传递给这个 Function 并执行，然后返回一个新的 CompletableFuture。
3.2 并行执行多个任务并等待所有任务完成
如果我们有多个异步任务需要并行执行，并且需要等待所有任务都完成后再进行下一步操作，可以使用 CompletableFuture.allOf 方法。
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class ParallelTasks {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 第一个异步任务
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "任务 1 的结果";
});
// 第二个异步任务
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "任务 2 的结果";
});
// 等待所有任务完成
CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2);
// 当所有任务完成后，获取每个任务的结果
CompletableFuture<Object[]> allResults = allFutures.thenApply(v -> {
return new Object[]{future1.join(), future2.join()};
});
// 获取最终结果数组
Object[] results = allResults.get();
for (Object result : results) {
System.out.println(result);
}
}
}
这里，CompletableFuture.allOf 方法接收多个 CompletableFuture 对象，返回一个新的 CompletableFuture，当所有传入的任务都完成时，这个新的 CompletableFuture 才会完成。
四、CompletableFuture 的异常处理
在异步编程中，异常处理是非常重要的。CompletableFuture 提供了 exceptionally 方法来处理异常。
import java.util.concurrent.CompletableFuture;
public class ExceptionHandling {
public static void main(String[] args) {
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
// 模拟抛出异常
throw new RuntimeException("模拟异常");
}).exceptionally(ex -> {
System.out.println("捕获到异常: " + ex.getMessage());
return "异常处理后的结果";
});
try {
String result = future.get();
System.out.println("最终结果: " + result);
} catch (Exception e) {
e.printStackTrace();
}
}
}
在这个例子中，当异步任务抛出异常时，exceptionally 方法会捕获这个异常，并返回一个默认的结果。
五、应用场景
5.1 高并发场景
在高并发的 Web 应用中，使用 CompletableFuture 可以提高系统的吞吐量。比如，当有大量用户请求时，我们可以使用异步编程来处理这些请求，避免线程阻塞。例如，在一个电商系统中，当用户下单时，我们可以使用 CompletableFuture 异步处理订单的创建、库存的扣减等操作，这样可以让主线程更快地响应其他请求。
5.2 数据处理场景
在数据处理中，我们可能需要同时处理多个数据源的数据。使用 CompletableFuture 可以并行处理这些数据源，提高数据处理的效率。比如，我们要从多个数据库中获取数据并进行汇总，就可以使用 CompletableFuture 异步地从每个数据库中获取数据，然后再进行合并。
六、技术优缺点
6.1 优点
- 提高性能：通过异步执行任务，充分利用多核 CPU 的资源，提高程序的执行效率。
- 代码简洁：CompletableFuture 提供了丰富的方法，使得异步编程的代码更加简洁易读。
- 异常处理方便：可以方便地处理异步任务中抛出的异常。
6.2 缺点
- 调试困难：由于异步任务是在不同的线程中执行，调试时可能会比较困难。
- 复杂度增加：对于复杂的异步任务组合，代码的复杂度会增加，理解和维护的难度也会相应提高。
七、注意事项
- 线程池的使用：CompletableFuture 默认使用
ForkJoinPool.commonPool()线程池，在高并发场景下，可能需要自定义线程池来避免资源竞争。 - 异常处理：一定要对异步任务中可能出现的异常进行处理，避免程序崩溃。
- 内存泄漏：如果异步任务持有大量的资源，要注意及时释放，避免内存泄漏。
八、文章总结
CompletableFuture 是 Java 中实现异步编程的强大工具，它提供了丰富的方法来实现任务的异步执行、组合和异常处理。通过合理使用 CompletableFuture，我们可以提高程序的性能和响应速度，适用于高并发和数据处理等多种场景。但是，在使用过程中也需要注意线程池的使用、异常处理和内存泄漏等问题。掌握 CompletableFuture 的深度应用技巧，可以让我们在 Java 编程中更加游刃有余。
评论