自定义线程池

自定义线程池

一.前置知识

《阿里巴巴JAVA开发手册》有这样一条强制规定：线程池不允许使用Executors去创建，而应该通过ThreadPoolExecutor方式，这样处理方式更加明确线程池运行规则，规避资源耗尽风险,能助于排查问题.

JVM调优排查问题可以看我这篇文章:暂时还没写完☺

FixedThreadPool SingleThreadPool
允许请求队列长度为Integer.MAX_VALUE可能会堆积大量请求从而导致OOM

CachedThreadPool ScheduledThreadPool
允许创建线程数量为Integer.MAX_VALUE可能会创建大量线程从而导致OOM

Fixed和Single两个线程池使用链表实现的阻塞队列，不设大小理论上队列容量无上限，所以可能会堆积大量请求从而导致OOM
Cached和Scheduled两个线程池maxSize使用Integer最大值，所以可能会创建大量线程从而导致OOM

Executors
让我们再看看Executors提供的那几个工厂方法。

newSingleThreadExecutor
创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。
此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

new ThreadPoolExecutor(1, 1,0L,TimeUnit.MILLISECONDS,new
LinkedBlockingQueue())

newFixedThreadPool
创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。
线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue());

newCachedThreadPool
创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，
那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。
此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,new
SynchronousQueue());

二.实操

方式一:

这种需要指定线程池名称

1. 编写配置文件

# 线程池配置参数
task:
  pool:
    corePoolSize: 10 # 设置核心线程数
    maxPoolSize: 20  # 设置最大线程数
    keepAliveTime: 300 # 设置空闲线程存活时间（秒）
    queueCapacity: 100 # 设置队列容量
    threadNamePrefix: "gblfy-signpolicy-asynnotify-" # 设置线程名称前缀
    awaitTerminationSeconds: 60 #  设置线程池等待终止时间(秒)
spring:
  main:
    allow-bean-definition-overriding: true

2. 编写配置类

@Data
@ConfigurationProperties(prefix = "task.pool")
@Component
public class MyThreadPoolConfig {
   
    /**
     * 核心线程数
     */
    private Integer corePoolSize;
    /**
     * 最大线程数
     */
    private Integer maxPoolSize;
    /**
     * 临时线程存活时间
     */
    private Integer keepAliveTime;
    /**
     * 设置队列容量
     */
    private Integer queueCapacity;
    /**
     * 设置线程名称前缀
     */
    private String threadNamePrefix;
    /**
     * 设置线程池等待终止时间(秒)
     */
    private Integer awaitTerminationSeconds;

3. 自定义线程池

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

import java.util.concurrent.*;

@Configuration
public class MyThreadFactory {
   

    @Autowired
    private MyThreadPoolConfig config;

    @Bean("myThreadPool")
    public Executor threadPoolExecutor(){
   
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //设置核心线程数
        executor.setCorePoolSize(config.getCorePoolSize());
        //设置最大线程数
        executor.setMaxPoolSize(config.getMaxPoolSize());
        //设置空闲线程存活时间
        executor.setKeepAliveSeconds(config.getKeepAliveTime());
        //设置队列大小
        executor.setQueueCapacity(config.getQueueCapacity());
        //设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住
        executor.setAwaitTerminationSeconds(config.getAwaitTerminationSeconds());
        //设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean
        executor.setWaitForTasksToCompleteOnShutdown(true);
        //线程池名的前缀
        executor.setThreadNamePrefix(config.getThreadNamePrefix());

		/**
         * 阻塞队列:
         *
         * ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。
         * LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。
         * PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。
         * DelayQueue： 一个使用优先级队列实现的无界阻塞队列。
         * SynchronousQueue： 一个不存储元素的阻塞队列。
         * LinkedTransferQueue： 一个由链表结构组成的无界阻塞队列。
         * LinkedBlockingDeque： 一个由链表结构组成的双向阻塞队列。
         *
         */

        /**
         * 拒绝处理策略