【Spring】-Spring之线程池

目录

• Spring 中的线程池

Spring 中的线程池

在spring 中其实也是有线程池的，一般使用的是ThreadPoolTaskExecutor 该类，其实现方法还是java.util.concurrent
中的ThreadPoolExecutor 线程

为了提高自定义化，一般都是自定义配置核心线程数，最大线程数，队列，以及拒绝策略，

下面是代码演示，

@Configuration // 告诉，该类是配置类
public class ThreadPoolConfig {

    // 获取服务器的cpu个数
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();

    private static final int COUR_SIZE = CPU_COUNT * 2;

    private static final int MAX_COUR_SIZE = CPU_COUNT * 4;

    /**
     * 线程池按以下行为执行任务
     * 1. 当线程数小于核心线程数时，创建线程。
     * 2. 当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。
     * 3. 当线程数大于等于核心线程数，且任务队列已满
     * -1 若线程数小于最大线程数，创建线程
     * -2 若线程数等于最大线程数，抛出异常，拒绝任务
     * <p>
     * 说明:
     * 1、默认值
     * * corePoolSize=1
     * * queueCapacity=Integer.MAX_VALUE
     * * maxPoolSize=Integer.MAX_VALUE
     * * keepAliveTime=60s
     * * allowCoreThreadTimeout=false
     * * rejectedExecutionHandler=AbortPolicy()
     * 2、如何来设置
     * * 需要根据几个值来决定
     * - tasks ：每秒的任务数，假设为1000
     * - taskcost：每个任务花费时间，假设为0.1s
     * - responsetime：系统允许容忍的最大响应时间，假设为1s
     * * 做几个计算
     * - corePoolSize = 每秒需要多少个线程处理？
     * * 一颗CPU核心同一时刻只能执行一个线程，然后操作系统切换上下文，核心开始执行另一个线程的代码，以此类推，超过cpu核心数，就会放入队列，如果队列也满了，就另起一个新的线程执行，所有推荐：corePoolSize = ((cpu核心数 * 2) + 有效磁盘数)，java可以使用Runtime.getRuntime().availableProcessors()获取cpu核心数
     * - queueCapacity = (coreSizePool/taskcost)*responsetime
     * * 计算可得 queueCapacity = corePoolSize/0.1*1。意思是队列里的线程可以等待1s，超过了的需要新开线程来执行
     * * 切记不能设置为Integer.MAX_VALUE，这样队列会很大，线程数只会保持在corePoolSize大小，当任务陡增时，不能新开线程来执行，响应时间会随之陡增。
     * - maxPoolSize = (max(tasks)- queueCapacity)/(1/taskcost)
     * * 计算可得 maxPoolSize = (1000-corePoolSize)/10，即(每秒并发数-corePoolSize大小) / 10
     * * （最大任务数-队列容量）/每个线程每秒处理能力 = 最大线程数
     * - rejectedExecutionHandler：根据具体情况来决定，任务不重要可丢弃，任务重要则要利用一些缓冲机制来处理
     * - keepAliveTime和allowCoreThreadTimeout采用默认通常能满足
     * 计算密集型线程池：数量一般为 N+1个 N为CPU核心数
     * IO密集型：数量一般为：2N + 1个 N为CPU核心数
     */
    @Bean(name = "commonThreadPool")  // 自动注入到bean中
    public ThreadPoolTaskExecutor threadPoolTaskExecutor() {

        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        /**
         * corePoolSize：核心线程数
         *  * 核心线程会一直存活，及时没有任务需要执行
         *  * 当线程数小于核心线程数时，即使有线程空闲，线程池也会优先创建新线程处理
         *  * 设置allowCoreThreadTimeout=true（默认false）时，核心线程会超时关闭
         */
        threadPoolTaskExecutor.setCorePoolSize(COUR_SIZE);          // 设置核心线程数
        /**
         * maxPoolSize：最大线程数
         *  * 当线程数>=corePoolSize，且任务队列已满时。线程池会创建新线程来处理任务
         *  * 当线程数=maxPoolSize，且任务队列已满时，线程池会拒绝处理任务而抛出异常
         */
        threadPoolTaskExecutor.setMaxPoolSize(MAX_COUR_SIZE);       // 配置最大线程数
        /**
         * queueCapacity：任务队列容量（阻塞队列）
         *  * 当核心线程数达到最大时，新任务会放在队列中排队等待执行
         */
        threadPoolTaskExecutor.setQueueCapacity(100); // 配置队列容量（这里设置成最大线程数的四倍）
        threadPoolTaskExecutor.setThreadNamePrefix("mapping-thread");  // 给线程池设置名称
        /**
         *  rejectedExecutionHandler：任务拒绝处理器
         *    * 两种情况会拒绝处理任务：
         *        - 当线程数已经达到maxPoolSize，切队列已满，会拒绝新任务
         *        - 当线程池被调用shutdown()后，会等待线程池里的任务执行完毕，再shutdown。如果在调用shutdown()和线程池真正shutdown之间提交任务，会拒绝新任务
         *    * 线程池会调用rejectedExecutionHandler来处理这个任务。如果没有设置默认是AbortPolicy，会抛出异常
         *    * ThreadPoolExecutor类有几个内部实现类来处理这类情况：
         *        - AbortPolicy 丢弃任务，抛运行时异常
         *        - CallerRunsPolicy 执行任务
         *        - DiscardPolicy 忽视，什么都不会发生
         *        - DiscardOldestPolicy 从队列中踢出最先进入队列（最后一个执行）的任务
         */
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 线程之间传递对象
        threadPoolTaskExecutor.setTaskDecorator(null);
        threadPoolTaskExecutor.initialize();
        return threadPoolTaskExecutor;
    }

}

异步线程池也可以配置

@Configuration // 告诉其，是一个配置类
@EnableAsync  // 激活spring 异步注解
public class AsyncConfig {


    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();

    private static final int CORE_POOL_SIZE = CPU_COUNT * 2;

    private static final int MAX_POOL_SIZE = CPU_COUNT * 4;


    @Bean
    public TaskExecutor taskExecutor() {
        // 采用spring 中的线程池配置，优点是比自己配置线程池更简单
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 设置核心线程数
        executor.setCorePoolSize(CORE_POOL_SIZE);
        // 设置最大线程数
        executor.setMaxPoolSize(MAX_POOL_SIZE);
        // 设置队列
        executor.setQueueCapacity(100);
        // 设置线程池名称
        executor.setThreadNamePrefix("pipeline-async-");
        // 线程之间传递对象
        executor.setTaskDecorator(null);
        executor.initialize();
        return executor;
    }

}