Java中常用的异步方法(核心用法和场景)

// 方式1：直接new Thread
new Thread(() -> {
    // 异步执行的任务（如IO操作、耗时计算）
    System.out.println("异步任务执行中：" + Thread.currentThread().getName());
}).start();
// 方式2：线程池（推荐，避免频繁创建线程）
ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> {
    // 异步任务
});
// 注意：使用后需关闭线程池（优雅关闭）
executor.shutdown();

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();
}

// 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()); // 完成后关闭线程池

@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;
    }
}

@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);
        }
    }
}

@Autowired
private AsyncService asyncService;
public void testAsync() {
    // 调用无返回值异步方法
    asyncService.asyncTask();
    // 调用有返回值异步方法
    CompletableFuture<String> future = asyncService.asyncTaskWithResult();
    future.thenAccept(result -> System.out.println("Spring异步结果：" + result));
}

// 异步文件读取示例
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();
    }
});

// 异步获取单个结果
Mono<String> mono = Mono.fromSupplier(() -> {
    Thread.sleep(1000);
    return "Reactor异步结果";
}).subscribeOn(Schedulers.boundedElastic()); // 指定异步线程池
// 订阅（触发执行）
mono.subscribe(result -> System.out.println("Reactor结果：" + result));