线程池执行多线程案例

末蓝、 2023-06-30 02:17 14阅读 0赞

使用线程池执行多线程需要如下几个条件

首先是一个线程池，线程池包含一些初始化数据，包含队列大小，核心线程数，最大线程数。

然后是一个实现了 runnable的任务，将该任务当如到线程池中进行执行。

线程池配置：

public class ThreadPoolManager<T> {
    
        /**
         * 根据cpu的数量动态的配置核心线程数和最大线程数
         */
        private static final int CPU_COUNT         = Runtime.getRuntime().availableProcessors();
    
        /**
         * 核心线程数 = CPU核心数 + 1
         */
        private static final int CORE_POOL_SIZE    = CPU_COUNT + 1;
    
        /**
         * 线程池最大线程数 = CPU核心数 * 2 + 1
         */
        private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    
        /**
         * 非核心线程闲置时超时1s
         */
        private static final int KEEP_ALIVE        = 1;
    
    
        private ThreadPoolExecutor executor;
    
    
    
        private ThreadPoolManager() {
    
        }
    
        private static ThreadPoolManager sInstance;
    
        public synchronized static ThreadPoolManager getsInstance() {
            if (sInstance == null) {
                sInstance = new ThreadPoolManager();
            }
            return sInstance;
        }
    
    
        /**
         * 开启一个无返回值的线程
         * @param r
         */
        public void execute(Runnable r) {
            if (executor == null) {
                /**
                 * corePoolSize:核心线程数
                 * maximumPoolSize：线程池所容纳最大线程数(workQueue队列满了之后才开启)
                 * keepAliveTime：非核心线程闲置时间超时时长
                 * unit：keepAliveTime的单位
                 * workQueue：等待队列，存储还未执行的任务
                 * threadFactory：线程创建的工厂
                 * handler：异常处理机制
                 *
                 */
                executor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE,
                        KEEP_ALIVE, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1000),
                        Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
            }
            // 把一个任务丢到了线程池中
            executor.execute(r);
        }
    
        /**
         * 开启一个有返回结果的线程
         * @param r
         * @return
         */
        public Future<T> submit(Callable<T> r) {
            if (executor == null) {
                /**
                 * corePoolSize:核心线程数
                 * maximumPoolSize：线程池所容纳最大线程数(workQueue队列满了之后才开启)
                 * keepAliveTime：非核心线程闲置时间超时时长
                 * unit：keepAliveTime的单位
                 * workQueue：等待队列，存储还未执行的任务
                 * threadFactory：线程创建的工厂
                 * handler：异常处理机制
                 *
                 */
                executor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE,
                        KEEP_ALIVE, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(20),
                        Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
            }
            // 把一个任务丢到了线程池中
            return executor.submit(r);
        }
    
        /**
         * 把任务移除等待队列
         * @param r
         */
        public void cancel(Runnable r) {
            if (r != null) {
                executor.getQueue().remove(r);
            }
        }
    
    }

2. 然后 新建一个任务类，实现 runnable 接口，重写run方法

public class ConverterTask implements Runnable {
    
        
    
    
        @Override
        public void run() {
            //自己的业务逻辑，调用需要并发的方法
            //todo
        }
    }

这样就可以简单的模拟一个线程池执行多线程的案例