在 Java 中，异步编程的核心目标是避免主线程阻塞，提升程序并发性能。以下是 Java 不同版本 / 框架中最常用的异步方法，按「基础 API→进阶框架」的逻辑梳理，附核心用法和场景：
一、基础 JDK 异步 API（Java 5+）
1. Thread/Runnable（最基础）
核心逻辑：通过新建线程执行异步任务，无返回值。适用场景：简单异步任务，无需结果、无需线程管理。
// 方式1：直接new Thread new Thread(() -> { // 异步执行的任务（如IO操作、耗时计算） System.out.println("异步任务执行中：" + Thread.currentThread().getName()); }).start(); // 方式2：线程池（推荐，避免频繁创建线程） ExecutorService executor = Executors.newFixedThreadPool(5); executor.submit(() -> { // 异步任务 }); // 注意：使用后需关闭线程池（优雅关闭） executor.shutdown();2. Future + Callable（Java 5+，支持返回值）
核心逻辑：Callable定义有返回值的异步任务，Future接收结果，支持阻塞获取 / 超时获取。适用场景：需要异步任务返回结果，可接受阻塞等待的场景。
ExecutorService executor = Executors.newSingleThreadExecutor(); // 提交Callable任务，返回Future Future<String> future = executor.submit(() -> { Thread.sleep(1000); // 模拟耗时操作 return "异步任务结果"; }); // 获取结果（阻塞直到任务完成） try { String result = future.get(); // 阻塞获取 // 或超时获取：future.get(2, TimeUnit.SECONDS); System.out.println("结果：" + result); } catch (InterruptedException | ExecutionException | TimeoutException e) { e.printStackTrace(); } finally { executor.shutdown(); }缺点：获取结果时仍会阻塞，无法链式调用。
3. CompletableFuture（Java 8+，推荐）
核心逻辑：基于「异步回调 + 流式编程」，解决 Future 阻塞问题，支持多任务组合、异常处理、非阻塞回调。适用场景：复杂异步场景（如多任务串行 / 并行、结果聚合、异步回调），Java 8 + 首选。
核心用法：
// 1. 异步执行无返回值任务 CompletableFuture.runAsync(() -> { System.out.println("无返回值异步任务：" + Thread.currentThread().getName()); }); // 2. 异步执行有返回值任务（默认使用ForkJoinPool.commonPool()） CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> { Thread.sleep(1000); return "有返回值的异步结果"; }); // 3. 非阻塞回调（任务完成后处理结果） future.thenAccept(result -> System.out.println("回调处理结果：" + result)) .exceptionally(e -> { // 异常处理 System.err.println("任务异常：" + e.getMessage()); return null; }); // 4. 多任务组合（并行执行后聚合结果） CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> "任务1"); CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> "任务2"); // 等待所有任务完成，聚合结果 CompletableFuture<Void> allDone = CompletableFuture.allOf(task1, task2); allDone.join(); // 阻塞等待所有任务完成（也可改用thenRun异步处理） String result = task1.join() + " + " + task2.join(); System.out.println("聚合结果：" + result); // 5. 指定自定义线程池（避免使用默认公共池） ExecutorService customPool = Executors.newFixedThreadPool(3); CompletableFuture.supplyAsync(() -> "自定义线程池执行", customPool) .thenRun(() -> System.out.println("完成")) .whenComplete((v, e) -> customPool.shutdown()); // 完成后关闭线程池二、Spring 框架中的异步方法（Spring 3+）
Spring 通过注解简化异步开发，核心是@Async。
1. 基础使用（@Async）
步骤 1：开启异步支持（配置类 / 启动类）
@Configuration @EnableAsync // 开启异步 public class AsyncConfig { // 自定义线程池（可选，默认使用SimpleAsyncTaskExecutor） @Bean public Executor taskExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(5); executor.setMaxPoolSize(10); executor.setQueueCapacity(20); executor.setThreadNamePrefix("Async-"); executor.initialize(); return executor; } }步骤 2：定义异步方法
@Service public class AsyncService { // 无返回值异步方法 @Async public void asyncTask() { System.out.println("Spring异步任务：" + Thread.currentThread().getName()); } // 有返回值异步方法（返回Future/CompletableFuture） @Async public CompletableFuture<String> asyncTaskWithResult() { try { Thread.sleep(1000); return CompletableFuture.completedFuture("Spring异步结果"); } catch (InterruptedException e) { return CompletableFuture.failedFuture(e); } } }步骤 3：调用异步方法
@Autowired private AsyncService asyncService; public void testAsync() { // 调用无返回值异步方法 asyncService.asyncTask(); // 调用有返回值异步方法 CompletableFuture<String> future = asyncService.asyncTaskWithResult(); future.thenAccept(result -> System.out.println("Spring异步结果：" + result)); }2. 注意事项
- 异步方法不能是
private/static，且不能在同一个类中调用（Spring AOP 代理机制）； - 推荐自定义线程池，避免默认线程池的性能问题；
- 异常处理：可通过
@Async结合CompletableFuture捕获异常，或自定义AsyncUncaughtExceptionHandler处理无返回值方法的异常。
三、其他常用异步场景
1. 异步 IO（Java NIO 2 / AIO）
适用于高并发 IO 场景（如网络通信、文件读写），核心是AsynchronousFileChannel/AsynchronousSocketChannel：
// 异步文件读取示例 Path path = Paths.get("test.txt"); AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.READ); ByteBuffer buffer = ByteBuffer.allocate(1024); // 异步读取，通过回调处理结果 channel.read(buffer, 0, null, new CompletionHandler<Integer, Void>() { @Override public void completed(Integer bytesRead, Void attachment) { System.out.println("读取字节数：" + bytesRead); buffer.flip(); // 处理读取的数据 } @Override public void failed(Throwable exc, Void attachment) { exc.printStackTrace(); } });2. 响应式编程（Project Reactor/Spring WebFlux）
适用于非阻塞响应式场景，核心是Mono/Flux：
// 异步获取单个结果 Mono<String> mono = Mono.fromSupplier(() -> { Thread.sleep(1000); return "Reactor异步结果"; }).subscribeOn(Schedulers.boundedElastic()); // 指定异步线程池 // 订阅（触发执行） mono.subscribe(result -> System.out.println("Reactor结果：" + result));四、核心选型建议
| 场景 | 推荐方案 |
|---|---|
| Java 8+ 简单异步 / 多任务组合 | CompletableFuture |
| Spring 项目中的业务异步 | @Async + 自定义线程池 |
| 高并发 IO（文件 / 网络） | Java AIO / Netty |
| 响应式非阻塞系统 | Spring WebFlux + Reactor |
| 简单无返回值异步（低并发） | Thread + 线程池 |
关键优化点：
- 所有异步场景都应使用线程池（避免频繁创建线程）；
- 避免异步任务中的阻塞操作（如同步 IO、锁等待），否则会耗尽线程池；
- 异步任务必须处理异常（如 CompletableFuture 的 exceptionally、Spring 的异常处理器）。
