spring boot 异步线程池的使用详解

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

# 异步线程池配置
async.executor.thread.core_pool_size=2
async.executor.thread.max_pool_size=10
async.executor.thread.queue_capacity=100
async.executor.thread.name.prefix=async-
async.executor.thread.keep_alive_seconds=60
async.executor.thread.await_termination_seconds=60

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
@Configuration
@EnableAsync
public class AsyncConfig {
    @Value("${async.executor.thread.core_pool_size}")
    private int corePoolSize;
    @Value("${async.executor.thread.max_pool_size}")
    private int maxPoolSize;
    @Value("${async.executor.thread.queue_capacity}")
    private int queueCapacity;
    @Value("${async.executor.thread.name.prefix}")
    private String namePrefix;
    @Value("${async.executor.thread.keep_alive_seconds}")
    private int keepAliveSeconds;
    @Value("${async.executor.thread.await_termination_seconds}")
    private int awaitTerminationSeconds;
    @Bean(name = "taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 设置核心线程数
        executor.setCorePoolSize(corePoolSize);
        // 设置最大线程数
        executor.setMaxPoolSize(maxPoolSize);
        // 设置队列容量
        executor.setQueueCapacity(queueCapacity);
        // 设置线程名称前缀
        executor.setThreadNamePrefix(namePrefix);
        // 线程空闲时的存活时间
        executor.setKeepAliveSeconds(keepAliveSeconds);
        // 关闭线程池等待任务完成的最长时间
        executor.setAwaitTerminationSeconds(awaitTerminationSeconds);
        // 关闭线程池等待已提交线程执行完毕
        executor.setWaitForTasksToCompleteOnShutdown(true);
        // 异常策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
@Service
public class AsyncService {
    // 在需要使用异步处理的方法上添加注解
    @Async("taskExecutor")
    public void executeAsyncTask() {
        System.out.println("执行异步任务 - " + Thread.currentThread().getName());
        try {
            // 模拟长时间运行的任务
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class AsyncController {
    @Autowired
    private AsyncService asyncService;
    @GetMapping("/async")
    public String handleAsyncRequest() {
        asyncService.executeAsyncTask();
        return "异步任务已启动";
    }
}