spring boot自定义线程池

线程池七大参数

public ThreadPoolExecutor(
	int corePoolSize,//核心线程数量
	int maximumPoolSize,//最大线程数
	long keepAliveTime,//最大空闲时间
	TimeUnit unit,//时间单位
	BlockingQueue<Runnable> workQueue,// 阻塞队列
	ThreadFactory threadFactory,//线程工厂
	RejectedExecutionHandler handler //拒绝策略
}

handler 拒绝策略：

handler ：表示当 workQueue 已满，且池中的线程数达到 maximumPoolSize 时，线程池拒绝添加新任务时采取的策略。（可以不指定）

策略	BB
ThreadPoolExecutor.AbortPolicy()	抛出RejectedExecutionException异常。默认策略
ThreadPoolExecutor.CallerRunsPolicy()	由向线程池提交任务的线程来执行该任务
ThreadPoolExecutor.DiscardPolicy()	抛弃当前的任务
ThreadPoolExecutor.DiscardOldestPolicy()	抛弃最旧的任务（最先提交而没有得到执行的任务

属性配置

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "pool.thread")
// @Component
@Data
public class ThreadPoolConfigProperties {

    private Integer coreSize;

    private Integer maxSize;

    private Integer keepAliveTime;
    
}

属性提示

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

#配置线程池
pool.thread.coreSize=20
pool.thread.maxSize=200
pool.thread.keepAliveTime=10

线程池配置类

import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@EnableConfigurationProperties(ThreadPoolConfigProperties.class)
@Configuration
public class MyThreadConfig {

    @Bean
    public ThreadPoolExecutor threadPoolExecutor(ThreadPoolConfigProperties configPool) {
        return new ThreadPoolExecutor(
                configPool.getCoreSize(),
                configPool.getMaxSize(),
                configPool.getKeepAliveTime(),
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(100000),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
    }
}