线程池配置工具类

绝地灬酷狼 2023-09-25 00:19 64阅读 0赞

### 线程池配置工具类 ###

*   *  一 单例的线程池工具类 ThreadPoolUtils
     *  二 创建线程池的工厂对象 MyThreadFactory
     *  三 线程池拒绝策略 ThreadRejectedExecutionHandler
     *  四 将线程池交给spring容器管理 ThreadPoolConfig

## 一 单例的线程池工具类 ThreadPoolUtils ##

import java.util.List;
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @Desc 单例的线程池工具类
     */
    
    public class ThreadPoolUtils {
        
    
        /**
         * 系统可用计算资源
         */
        private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    
        /**
         * 核心线程数
         */
        private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    
        /**
         * 最大线程数
         */
        private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    
        /**
         * 空闲线程存活时间
         */
        private static final int KEEP_ALIVE_SECONDS = 30;
    
        /**
         * 工作队列
         */
        private static final BlockingQueue<Runnable> POOL_WORK_QUEUE = new LinkedBlockingQueue<>(128);
    
        /**
         * 工厂模式
         */
        private static final MyThreadFactory MY_THREAD_FACTORY = new MyThreadFactory();
    
        /**
         * 饱和策略
         */
        private static final ThreadRejectedExecutionHandler THREAD_REJECTED_EXECUTION_HANDLER = new ThreadRejectedExecutionHandler.CallerRunsPolicy();
    
        /**
         * 线程池对象
         */
        private static final ThreadPoolExecutor THREAD_POOL_EXECUTOR;
    
        /**
         * 声明式定义线程池工具类对象静态变量，在所有线程中同步
         */
        private static volatile ThreadPoolUtils threadPoolUtils = null;
    
    
        /**
         * 初始化线程池静态代码块
         */
        static {
        
            THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(
                    //核心线程数
                    CORE_POOL_SIZE,
                    //最大线程数
                    MAXIMUM_POOL_SIZE,
                    //空闲线程执行时间
                    KEEP_ALIVE_SECONDS,
                    //空闲线程执行时间单位
                    TimeUnit.SECONDS,
                    //工作队列（或阻塞队列）
                    POOL_WORK_QUEUE,
                    //工厂模式
                    MY_THREAD_FACTORY,
                    //饱和策略
                    THREAD_REJECTED_EXECUTION_HANDLER
                    );
        }
    
    
        /**
         * 线程池工具类空参构造方法
         */
        private ThreadPoolUtils() {
        }
    
        /**
         * 获取线程池工具类实例
         * @return
         */
    
        public static ThreadPoolUtils getNewInstance(){
        
            if (threadPoolUtils == null) {
        
                synchronized (ThreadPoolUtils.class) {
        
                    if (threadPoolUtils == null) {
        
                        threadPoolUtils = new ThreadPoolUtils();
                    }
                }
            }
            return threadPoolUtils;
        }
    
    
        public  ThreadPoolExecutor  threadPoolExecutor(){
        
            return THREAD_POOL_EXECUTOR;
        }
        /**
         * 执行线程任务
         * @param runnable 任务线程
         */
        public void executor(Runnable runnable) {
        
            THREAD_POOL_EXECUTOR.execute(runnable);
        }
    
        /**
         * 获取线程池状态
         * @return 返回线程池状态
         */
        public boolean isShutDown(){
        
            return THREAD_POOL_EXECUTOR.isShutdown();
        }
    
        /**
         * 停止正在执行的线程任务
         * @return 返回等待执行的任务列表
         */
        public List<Runnable> shutDownNow(){
        
            return THREAD_POOL_EXECUTOR.shutdownNow();
        }
    
        /**
         * 关闭线程池
         */
        public void showDown(){
        
            THREAD_POOL_EXECUTOR.shutdown();
        }
    
    
        /**
         * 关闭线程池后判断所有任务是否都已完成
         * @return
         */
        public boolean isTerminated(){
        
            return THREAD_POOL_EXECUTOR.isTerminated();
        }
    }

## 二 创建线程池的工厂对象 MyThreadFactory ##

import java.util.concurrent.ThreadFactory;
    
    /**
     * @Desc 创建线程池的工厂对象
     */
    public class MyThreadFactory implements ThreadFactory {
        
    
        /**
         * 该方法用来创建线程
         * @param r
         * @return
         */
        @Override
        public Thread newThread(Runnable r) {
        
            Thread newThread = new Thread(r);
            return newThread;
        }
    }

## 三 线程池拒绝策略 ThreadRejectedExecutionHandler ##

import java.util.concurrent.RejectedExecutionException;
    import java.util.concurrent.RejectedExecutionHandler;
    import java.util.concurrent.ThreadPoolExecutor;
    
    /**
     * @Desc 线程池拒绝策略
     */
    
    public class ThreadRejectedExecutionHandler implements RejectedExecutionHandler{
        
    
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        }
    
        /**
         * 饱和策略一：调用者线程执行策略
         * 在该策略下，在调用者中执行被拒绝任务的run方法。除非线程池showdown，否则直接丢弃线程
         */
        public static class CallerRunsPolicy extends ThreadRejectedExecutionHandler {
        
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        
                //判断线程池是否在正常运行，如果线程池在正常运行则由调用者线程执行被拒绝的任务。如果线程池停止运行，则直接丢弃该任务
                if (!executor.isShutdown()){
        
                    r.run();
                }
            }
        }
    
    
        /**
         * 饱和策略二：终止策略
         * 在该策略下，丢弃被拒绝的任务，并抛出拒绝执行异常
         */
        public static class AbortPolicy extends ThreadRejectedExecutionHandler {
        
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        
                throw new RejectedExecutionException("请求任务：" + r.toString() + "，线程池负载过高执行饱和终止策略！");
            }
        }
    
    
        /**
         * 饱和策略三：丢弃策略
         * 在该策略下，什么都不做直接丢弃被拒绝的任务
         */
        public static class DiscardPolicy extends ThreadRejectedExecutionHandler {
        
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        }
        }
    
        /**
         * 饱和策略四：弃老策略
         * 在该策略下，丢弃最早放入阻塞队列中的线程，并尝试将拒绝任务加入阻塞队列
         */
        public static class DiscardOldestPolicy extends ThreadRejectedExecutionHandler {
        
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        
                //判断线程池是否正常运行，如果线程池正常运行则弹出（或丢弃）最早放入阻塞队列中的任务，并尝试将拒绝任务加入阻塞队列。如果线程池停止运行，则直接丢弃该任务
                if (!executor.isShutdown()){
        
                    executor.getQueue().poll();
                    executor.execute(r);
                }
            }
        }
    }

## 四 将线程池交给spring容器管理 ThreadPoolConfig ##

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import java.util.concurrent.ThreadPoolExecutor;
    
    /**
     * @ClassName: ThreadPoolConfig
     * @Description: ThreadPoolConfig
     * @Date: 2023/03/15 19:40
     **/
    @Configuration
    public class ThreadPoolConfig {
        
        @Bean
        public ThreadPoolExecutor threadPoolExecutor() {
        
            return ThreadPoolUtils.getNewInstance().threadPoolExecutor();
        }
    }