Java CompletableFuture supplyAsync与runAsync的区别与选择
Java CompletableFuture supplyAsync 与 runAsync 的区别与选择
在Java的异步编程领域，CompletableFuture 是一个强大的工具，它为处理异步操作提供了丰富的方法。其中，supplyAsync 和 runAsync 是两个常用的静态方法，用于创建异步任务。虽然它们看起来相似，但在功能和使用场景上存在一些关键的区别。理解这些区别对于正确选择和使用它们至关重要。
基本概念
CompletableFuture 是Java 8引入的一个类，它实现了 Future 和 CompletionStage 接口。它允许我们以更灵活和可组合的方式处理异步操作，支持链式调用、回调处理以及异常处理等功能。
supplyAsync 和 runAsync 方法都是 CompletableFuture 的静态方法，用于异步执行任务。它们的主要区别在于任务的返回值。
supplyAsync 方法
supplyAsync 方法用于异步执行一个有返回值的任务。其方法签名如下：
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)
第一个重载方法使用默认的 ForkJoinPool.commonPool() 作为执行器来异步执行任务，而第二个重载方法允许我们指定一个自定义的执行器。
下面是一个简单的示例，展示如何使用 supplyAsync 方法：
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class SupplyAsyncExample {
public static void main(String[] args) throws ExecutionException, InterruptedException {
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
// 模拟一个耗时操作
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Hello, CompletableFuture!";
});
// 获取异步任务的结果
String result = future.get();
System.out.println(result);
}
}
在这个示例中，supplyAsync 方法接收一个 Supplier 接口的实现，该接口的 get 方法包含了异步执行的任务逻辑。任务执行完成后，CompletableFuture 的 get 方法可以获取任务的返回值。
runAsync 方法
runAsync 方法用于异步执行一个没有返回值的任务。其方法签名如下：
public static CompletableFuture<Void> runAsync(Runnable runnable)
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
同样，第一个重载方法使用默认的 ForkJoinPool.commonPool() 作为执行器，第二个重载方法允许指定自定义执行器。
以下是使用 runAsync 方法的示例：
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class RunAsyncExample {
public static void main(String[] args) throws ExecutionException, InterruptedException {
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
// 模拟一个耗时操作
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task completed without return value.");
});
// 获取异步任务的结果（这里返回值为null）
Void result = future.get();
System.out.println(result);
}
}
在这个示例中，runAsync 方法接收一个 Runnable 接口的实现，该接口的 run 方法包含了异步执行的任务逻辑。由于任务没有返回值，CompletableFuture 的 get 方法返回 null。
区别分析
- 返回值类型：
supplyAsync方法返回一个CompletableFuture<U>，其中U是任务的返回值类型。而runAsync方法返回一个CompletableFuture<Void>，表示任务没有返回值。 - 任务接口：
supplyAsync方法接收一个Supplier<U>接口，该接口的get方法需要返回一个值。而runAsync方法接收一个Runnable接口，该接口的run方法没有返回值。 - 适用场景：如果异步任务需要返回一个结果，例如从数据库查询数据、计算某个值等，应该使用
supplyAsync方法。如果异步任务只是执行一些不需要返回结果的操作，例如记录日志、发送邮件等，应该使用runAsync方法。
执行器的选择
无论是 supplyAsync 还是 runAsync 方法，都提供了使用默认执行器和自定义执行器的重载方法。默认执行器 ForkJoinPool.commonPool() 是一个共享的线程池，适用于大多数情况。然而，在某些场景下，使用自定义执行器可能更合适。
- 自定义线程池：如果异步任务的数量较多或者任务执行时间较长，可能会导致默认线程池的性能问题。此时，可以创建一个自定义的线程池，并将其作为执行器传递给
supplyAsync或runAsync方法。
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CustomExecutorExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(10);
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
// 异步任务逻辑
return "Task result";
}, executor);
future.thenAccept(System.out::println).thenRun(() -> executor.shutdown());
}
}
在这个示例中，我们创建了一个固定大小为10的线程池，并将其作为执行器传递给 supplyAsync 方法。任务完成后，我们使用 thenRun 方法关闭线程池。
- 不同类型的执行器：除了固定大小的线程池，还可以使用其他类型的执行器，如
CachedThreadPool、ScheduledThreadPool等，根据具体的需求选择合适的执行器。
链式调用和组合操作
CompletableFuture 的强大之处在于它支持链式调用和组合操作。无论是 supplyAsync 还是 runAsync 创建的 CompletableFuture，都可以进行链式调用，以处理任务的结果、错误或执行后续操作。
- 处理任务结果：
thenApply、thenAccept和thenRun方法可以用于处理CompletableFuture的结果。
import java.util.concurrent.CompletableFuture;
public class ChainingExample {
public static void main(String[] args) {
CompletableFuture.supplyAsync(() -> "Hello")
.thenApply(String::toUpperCase)
.thenAccept(System.out::println);
}
}
在这个示例中，supplyAsync 创建的 CompletableFuture 首先调用 thenApply 方法将字符串转换为大写，然后调用 thenAccept 方法打印结果。
- 处理异常：
exceptionally和handle方法可以用于处理CompletableFuture中的异常。
import java.util.concurrent.CompletableFuture;
public class ExceptionHandlingExample {
public static void main(String[] args) {
CompletableFuture.supplyAsync(() -> {
if (Math.random() < 0.5) {
throw new RuntimeException("Simulated exception");
}
return "Success";
})
.exceptionally(ex -> {
System.out.println("Caught exception: " + ex.getMessage());
return "Default value";
})
.thenAccept(System.out::println);
}
}
在这个示例中，exceptionally 方法捕获异步任务中的异常，并返回一个默认值。
- 组合多个 CompletableFuture：
thenCombine、thenAcceptBoth和runAfterBoth等方法可以用于组合多个CompletableFuture的结果。
import java.util.concurrent.CompletableFuture;
public class CompletionStageCombinationExample {
public static void main(String[] args) {
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");
CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (s1, s2) -> s1 + " " + s2);
combinedFuture.thenAccept(System.out::println);
}
}
在这个示例中，thenCombine 方法将两个 CompletableFuture 的结果组合在一起。
性能考虑
在使用 supplyAsync 和 runAsync 方法时，性能是一个需要考虑的因素。以下是一些性能优化的建议：
- 合理选择执行器：如前所述，根据任务的特点和数量选择合适的执行器，避免使用默认线程池导致的性能问题。
- 减少任务的粒度：如果异步任务包含多个子任务，可以考虑将它们合并为一个任务，以减少线程切换的开销。
- 避免不必要的阻塞：尽量使用非阻塞的方式处理
CompletableFuture的结果，例如使用thenApply、thenAccept等方法，而不是直接调用get方法阻塞线程。
示例场景分析
- 数据查询：假设我们需要从数据库中查询用户信息。由于查询操作可能比较耗时，我们可以使用
supplyAsync方法异步执行查询，并返回查询结果。
import java.util.concurrent.CompletableFuture;
public class DatabaseQueryExample {
public static CompletableFuture<String> queryUserInfo() {
return CompletableFuture.supplyAsync(() -> {
// 模拟数据库查询操作
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "User information";
});
}
public static void main(String[] args) {
queryUserInfo().thenAccept(System.out::println);
}
}
- 日志记录：在应用程序中，记录日志是一个常见的操作，但通常不需要返回结果。我们可以使用
runAsync方法异步记录日志，以避免阻塞主线程。
import java.util.concurrent.CompletableFuture;
public class LoggingExample {
public static void logMessage(String message) {
CompletableFuture.runAsync(() -> {
// 模拟日志记录操作
System.out.println("Logging message: " + message);
});
}
public static void main(String[] args) {
logMessage("Application started");
}
}
- 复杂业务逻辑：在实际应用中，可能会遇到一些复杂的业务逻辑，需要多个异步任务协同工作。例如，我们需要先查询用户信息，然后根据用户信息发送邮件。
import java.util.concurrent.CompletableFuture;
public class ComplexBusinessLogicExample {
public static CompletableFuture<String> queryUserInfo() {
return CompletableFuture.supplyAsync(() -> {
// 模拟数据库查询操作
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "User information";
});
}
public static CompletableFuture<Void> sendEmail(String userInfo) {
return CompletableFuture.runAsync(() -> {
// 模拟发送邮件操作
System.out.println("Sending email with user info: " + userInfo);
});
}
public static void main(String[] args) {
queryUserInfo()
.thenCompose(ComplexBusinessLogicExample::sendEmail)
.thenRun(() -> System.out.println("Operation completed"));
}
}
在这个示例中，queryUserInfo 方法返回用户信息，然后使用 thenCompose 方法将用户信息传递给 sendEmail 方法，并在邮件发送完成后执行最终的操作。
与其他异步编程模型的比较
- 传统的 Future 接口：Java的
Future接口提供了一种基本的异步任务处理方式，但它的功能相对有限。例如，Future接口不支持链式调用和回调处理，获取任务结果时需要阻塞线程。而CompletableFuture继承自Future接口，并扩展了其功能，提供了更灵活和强大的异步编程能力。 - RxJava：RxJava 是一个基于观察者模式的异步编程库，它提供了丰富的操作符和功能。与
CompletableFuture相比，RxJava 更侧重于事件流的处理，适用于处理复杂的异步数据流场景。而CompletableFuture则更专注于单个异步任务的处理和组合，使用起来相对简单直接。
总结
CompletableFuture 的 supplyAsync 和 runAsync 方法为Java的异步编程提供了强大的支持。通过理解它们的区别和适用场景，我们可以根据具体的需求选择合适的方法，以实现高效、灵活的异步任务处理。同时，合理选择执行器、优化任务粒度以及避免不必要的阻塞等性能优化措施，也能进一步提升异步编程的性能。在实际应用中，结合链式调用、异常处理和组合操作等功能，可以构建出复杂而健壮的异步业务逻辑。与其他异步编程模型相比，CompletableFuture 提供了一种简洁且易于理解的异步编程方式，特别适合处理单个异步任务和简单的任务组合场景。