Spring boot 配置线程池无效 springboot自带的线程池

转载

数据大侠客 2023-09-07 22:59:37

文章标签 Spring boot 配置线程池无效 java spring 线程池 文章分类 spring boot 后端开发

ThreadPoolTaskExecutor类，其本质是对java.util.concurrent.ThreadPoolExecutor的包装。这个类则是spring包下的，是Spring为我们开发者提供的线程池类
Spring提供了xml给我们配置ThreadPoolTaskExecutor线程池，但是现在普遍都在用SpringBoot开发项目，所以直接上yaml或者properties配置即可，或者也可以使用@Configuration配置也行，下面演示配置和使用。

配置

application.properties

# 核心线程池数
spring.task.execution.pool.core-size=5
# 最大线程池数
spring.task.execution.pool.max-size=10
# 任务队列的容量
spring.task.execution.pool.queue-capacity=5
# 非核心线程的存活时间
spring.task.execution.pool.keep-alive=60
# 线程池的前缀名称
spring.task.execution.thread-name-prefix=线程前缀名

application.yaml

spring:
  task:
    execution:
      pool:
        #核心线程数
        core-size: 5
        #最大线程数
        max-size: 20
        #任务队列容量
        queue-capacity: 10
        #非核心线程存活时间
        keep-alive: 60
      #线程池前缀名称
      thread-name-prefix: 线程前缀名

config类

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @author: tanghaizhi
 * @CreateTime: 2022/4/26 9:38
 * @Description:
 */
@Configuration
public class AsyncScheduledTaskConfig {

    @Value("${spring.task.execution.pool.core-size}")
    private int corePoolSize;
    @Value("${spring.task.execution.pool.max-size}")
    private int maxPoolSize;
    @Value("${spring.task.execution.pool.queue-capacity}")
    private int queueCapacity;
    @Value("${spring.task.execution.thread-name-prefix}")
    private String namePrefix;
    @Value("${spring.task.execution.pool.keep-alive}")
    private int keepAliveSeconds;
    @Bean
    public ThreadPoolTaskExecutor threadPoolTaskExecutorInit() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //最大线程数
        executor.setMaxPoolSize(maxPoolSize);
        //核心线程数
        executor.setCorePoolSize(corePoolSize);
        //任务队列的大小
        executor.setQueueCapacity(queueCapacity);
        //线程前缀名
        executor.setThreadNamePrefix(namePrefix);
        //线程存活时间
        executor.setKeepAliveSeconds(keepAliveSeconds);

        /**
         * 拒绝处理策略
         * CallerRunsPolicy()：交由调用方线程运行，比如 main 线程。
         * AbortPolicy()：直接抛出异常。
         * DiscardPolicy()：直接丢弃。
         * DiscardOldestPolicy()：丢弃队列中最老的任务。
         */
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        //线程初始化
        executor.initialize();
        return executor;
    }
}

使用

测试使用类如下,需在启动类加上@EnableAsync和@EnableScheduling两个注解

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * @author: tanghaizhi
 * @CreateTime: 2022/4/26 9:42
 * @Description:
 */
@Component
public class ScheduleTask {

    @Qualifier("threadPoolTaskExecutorInit")
    @Autowired
    ThreadPoolTaskExecutor executor;

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    @Async("threadPoolTaskExecutorInit")
    @Scheduled(fixedRate = 2000)
    public void test1() {
        try {
            Thread.sleep(6000);
            System.out.println("线程池名称:" + Thread.currentThread().getName() + "-" + sdf.format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Scheduled(cron = "*/1 * * * * ?")
    public void test2() throws ExecutionException, InterruptedException {
        CompletableFuture<String> childThread = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+" start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" exit,time->"+System.currentTimeMillis());
            return Thread.currentThread().getName() + "任务结束";
        },executor);
        System.out.println("child thread result->"+childThread.get());
    }
}

运行结果如下

Spring boot 配置线程池无效 springboot自带的线程池_spring