Java异步编程实践

### 一、使用线程实现异步任务

在Java中，最基本的异步任务实现方式是通过创建新线程来执行耗时操作。下面是一个简单的例子：

```java
@Test
public void testThread() throws Exception {
System.out.println("主线程开始执行");
Thread thread = new Thread(() -> {
System.out.println("===任务开始===");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("===任务完成===");
});
thread.start();
System.out.println("主线程结束执行");
}
```

### 二、Future接口的应用

Future接口用于表示异步计算的结果。它提供了一种检查计算是否完成的方法，并能够获取计算结果或取消计算。然而，Future接口存在一些局限性，例如获取结果时会阻塞主线程。

```java
@Test
public void testFuture() throws Exception {
System.out.println("主线程开始执行");
ExecutorService executor = Executors.newFixedThreadPool(1);
Future future = executor.submit(() -> {
System.out.println("===任务开始===");
Thread.sleep(5000);
System.out.println("===任务完成===");
return 3;
});
// 获取结果时会阻塞主线程
// Integer result = future.get();
System.out.println("主线程结束执行");
executor.shutdown();
}
```

### 三、CompletableFuture类的使用

CompletableFuture类提供了更强大的异步编程能力，支持链式调用和组合多个异步任务。它结合了Future接口的功能，并增加了许多新的特性。

```java
@Test
public void testCompletableFuture() throws Exception {
System.out.println("主线程开始执行");
ExecutorService executor = Executors.newFixedThreadPool(2);
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
System.out.println("===任务开始===");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("===任务完成===");
return 3;
}, executor);
future.thenAccept(System.out::println);
System.out.println("主线程结束执行");
}
```

### 四、Spring框架中的@Async注解

Spring框架提供了@Async注解来简化异步方法的定义。要使用该注解，首先需要在配置类中启用异步支持。

#### XML配置方式

```xml

pool-size="2"
queue-capacity="100"
keep-alive="120"
rejection-policy="CALLER_RUNS" />
```

#### Java配置方式

```java
@Configuration
@EnableAsync
public class AsyncConfig {
@Bean
public TaskExecutor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(20);
executor.setQueueCapacity(1000);
executor.setKeepAliveSeconds(300);
executor.setThreadNamePrefix("async-thread-");
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
return executor;
}
}
```

#### 使用@Async注解

```java
@Service
public class MyService {
@Async
public void executeLongTask() {
System.out.println("正在执行一项耗时任务");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("任务完成");
}
}

@Test
public void testAsync() throws Exception {
System.out.println("主线程开始执行");
myService.executeLongTask();
System.out.println("主线程结束执行");
}
```

#### 返回值处理

如果异步方法需要返回值，可以使用`AsyncResult`包装返回值。

```java
@Test
public void testAsyncResult() throws Exception {
System.out.println("主线程开始执行");
Future future = myService.executeLongTaskWithResult();
System.out.println("主线程结束执行");
System.out.println("异步执行结果：" + future.get());
}

@Async
public Future executeLongTaskWithResult() {
System.out.println("正在执行一项耗时任务");
try {
Thread.sleep(8000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("任务完成");
return new AsyncResult<>(3);
}
```