// 方式1：直接new Thread
new Thread(() -> {
    // 異步執(zhí)行的任務（如IO操作、耗時計算）
    System.out.println("異步任務執(zhí)行中：" + Thread.currentThread().getName());
}).start();
// 方式2：線程池（推薦，避免頻繁創(chuàng)建線程）
ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> {
    // 異步任務
});
// 注意：使用后需關閉線程池（優(yōu)雅關閉）
executor.shutdown();

ExecutorService executor = Executors.newSingleThreadExecutor();
// 提交Callable任務，返回Future
Future<String> future = executor.submit(() -> {
    Thread.sleep(1000); // 模擬耗時操作
    return "異步任務結果";
});
// 獲取結果（阻塞直到任務完成）
try {
    String result = future.get(); // 阻塞獲取
    // 或超時獲?。篺uture.get(2, TimeUnit.SECONDS);
    System.out.println("結果：" + result);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
    e.printStackTrace();
} finally {
    executor.shutdown();
}

// 1. 異步執(zhí)行無返回值任務
CompletableFuture.runAsync(() -> {
    System.out.println("無返回值異步任務：" + Thread.currentThread().getName());
});
// 2. 異步執(zhí)行有返回值任務（默認使用ForkJoinPool.commonPool()）
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    Thread.sleep(1000);
    return "有返回值的異步結果";
});
// 3. 非阻塞回調(diào)（任務完成后處理結果）
future.thenAccept(result -> System.out.println("回調(diào)處理結果：" + result))
      .exceptionally(e -> { // 異常處理
          System.err.println("任務異常：" + e.getMessage());
          return null;
      });
// 4. 多任務組合（并行執(zhí)行后聚合結果）
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(() -> "自定義線程池執(zhí)行", 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() {
    // 調(diào)用無返回值異步方法
    asyncService.asyncTask();
    // 調(diào)用有返回值異步方法
    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);
// 異步讀取，通過回調(diào)處理結果
channel.read(buffer, 0, null, new CompletionHandler<Integer, Void>() {
    @Override
    public void completed(Integer bytesRead, Void attachment) {
        System.out.println("讀取字節(jié)數(shù)：" + bytesRead);
        buffer.flip();
        // 處理讀取的數(shù)據(jù)
    }
    @Override
    public void failed(Throwable exc, Void attachment) {
        exc.printStackTrace();
    }
});

// 異步獲取單個結果
Mono<String> mono = Mono.fromSupplier(() -> {
    Thread.sleep(1000);
    return "Reactor異步結果";
}).subscribeOn(Schedulers.boundedElastic()); // 指定異步線程池
// 訂閱（觸發(fā)執(zhí)行）
mono.subscribe(result -> System.out.println("Reactor結果：" + result));