在Spring Boot中配置自定义线程池并实现异步方法返回值

源码资源网

在Spring Boot中配置自定义线程池并实现异步方法返回值
在Spring Boot中配置自定义线程池并实现异步方法返回值，可以通过以下步骤完成。我们将使用 `@Async` 注解，并结合 `Future` 或 `CompletableFuture` 来实现异步返回值。
### 1. 添加依赖
确保在 `pom.xml` 中添加Spring Boot的依赖（如果你使用的是Maven）：

1. xml
   
2. <dependency>
   
3.     <groupId>org.springframework.boot</groupId>
   
4.     <artifactId>spring-boot-starter</artifactId>
   
5. </dependency>
   
6. <dependency>
   
7.     <groupId>org.springframework.boot</groupId>
   
8.     <artifactId>spring-boot-starter-web</artifactId>
   
9. </dependency>

复制代码

### 2. 启用异步支持
在你的主应用程序类或者配置类上添加 `@EnableAsync` 注解，以启用异步支持：

1. import org.springframework.boot.SpringApplication;
   
2. import org.springframework.boot.autoconfigure.SpringBootApplication;
   
3. import org.springframework.scheduling.annotation.EnableAsync;
   
4. @SpringBootApplication
   
5. @EnableAsync
   
6. public class AsyncApplication {
   
7.     public static void main(String[] args) {
   
8.         SpringApplication.run(AsyncApplication.class, args);
   
9.     }
   
10. }

复制代码

### 3. 配置自定义线程池
创建一个配置类来定义自定义线程池：

1. import org.springframework.context.annotation.Bean;
   
2. import org.springframework.context.annotation.Configuration;
   
3. import org.springframework.scheduling.annotation.EnableAsync;
   
4. import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
   
5. import java.util.concurrent.Executor;
   
6. @Configuration
   
7. @EnableAsync
   
8. public class AsyncConfig {
   
9.      @Bean(name = "taskExecutor")
   
10.     public Executor taskExecutor() {
    
11.         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    
12.         executor.setCorePoolSize(5); // 核心线程数
    
13.         executor.setMaxPoolSize(10); // 最大线程数
    
14.         executor.setQueueCapacity(25); // 队列容量
    
15.         executor.setThreadNamePrefix("Async-"); // 线程名称前缀
    
16.         executor.initialize();
    
17.         return executor;
    
18.     }
    
19. }

复制代码

或者

1. import org.springframework.context.annotation.Bean;
   
2. import org.springframework.context.annotation.Configuration;
   
3. import org.springframework.scheduling.annotation.EnableAsync;
   
4. import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
   
5. import java.util.concurrent.Executor;
   
6. import java.util.concurrent.RejectedExecutionHandler;
   
7. import java.util.concurrent.ThreadPoolExecutor;
   
8. @Configuration
   
9. @EnableAsync
   
10. public class AsyncConfig {
    
11.     @Bean(name = "taskExecutor")
    
12.     public Executor taskExecutor() {
    
13.         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    
14.         executor.setCorePoolSize(5); // 核心线程数
    
15.         executor.setMaxPoolSize(10); // 最大线程数
    
16.         executor.setQueueCapacity(25); // 队列容量
    
17.         executor.setThreadNamePrefix("Async-"); // 线程名称前缀
    
18.          // 设置拒绝执行处理器
    
19.         executor.setRejectedExecutionHandler(new RejectedExecutionHandler() {
    
20.             @Override
    
21.             public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
    
22.                 // 这里可以自定义拒绝策略
    
23.                 System.out.println("任务被拒绝: " + r.toString());
    
24.             }
    
25.         });
    
26.          executor.initialize();
    
27.         return executor;
    
28.     }
    
29. }

复制代码

### 4. 创建异步服务
创建一个服务类，并在需要异步执行的方法上添加 `@Async` 注解，返回 `CompletableFuture` ：

1. import org.springframework.scheduling.annotation.Async;
   
2. import org.springframework.stereotype.Service;
   
3. import java.util.concurrent.CompletableFuture;
   
4. @Service
   
5. public class AsyncService {
   
6.      @Async("taskExecutor") // 指定使用自定义线程池
   
7.     public CompletableFuture<String> asyncMethod() {
   
8.         try {
   
9.             // 模拟耗时操作
   
10.             Thread.sleep(3000);
    
11.             return CompletableFuture.completedFuture("异步方法执行完成");
    
12.         } catch (InterruptedException e) {
    
13.             return CompletableFuture.completedFuture("执行失败");
    
14.         }
    
15.     }
    
16. }

复制代码

### 5. 调用异步方法
在控制器中调用异步服务的方法，并处理返回值：

1. import org.springframework.beans.factory.annotation.Autowired;
   
2. import org.springframework.web.bind.annotation.GetMapping;
   
3. import org.springframework.web.bind.annotation.RestController;
   
4. import java.util.concurrent.CompletableFuture;
   
5. @RestController
   
6. public class AsyncController {
   
7.      @Autowired
   
8.     private AsyncService asyncService;
   
9.      @GetMapping("/startAsync")
   
10.     public CompletableFuture<String> startAsync() {
    
11.         return asyncService.asyncMethod();
    
12.     }
    
13. }

复制代码

### 6. 运行应用
启动你的Spring Boot应用程序，并访问 `/startAsync` 端点。你会看到异步方法将在后台运行，并且返回值会在完成后返回。
### 注意事项
- **线程池配置**：可以根据实际需求调整线程池的核心线程数、最大线程数和队列容量。
- **异常处理**：在异步方法中发生的异常会被捕获并返回，可以在调用处处理这些异常。
- **@Async注解**：确保在Spring管理的bean中使用，并且可以指定使用哪个线程池。
这样，你就可以在Spring Boot中使用自定义线程池配置和异步返回值的功能了！