线程池

线程池

 

 

Executors 封装 线程池（不推荐使用）

直接使用ThreadPoolExecutor ，根据业务需求灵活配置，避免OOM发生的风险。

 /**
         * 可缓存线程池
         * 同时执行的最大线程数是Integer.MAX_VALUE,是高度可伸缩的线程池。可能发生OOM异常。<br/>
         * 线程空闲时间60秒，工作线程处于空闲状态，可以回收工作线程复用。（threadlocal在线池复用的场景，要注意，容易产生脏数据）<br/>
         * 如果任务数持续增加，没有可复用的工作线程，将不断的创建新线程处理任务。
         */
        Executors.newCachedThreadPool();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                20L, TimeUnit.MICROSECONDS,
                new SynchronousQueue<Runnable>(), new MyThreadFactory());


        /**
         * 固定大小线程池<br/>
         * newFixedThreadPool核心线程数和同时执行最大线程数相等，并且固定一个数，不存在空闲线程，空闲线程没有任何作用，空闲时间设置为零。<br/>
         * newSingleThreadExecutor核心线程数和同时执行最大线程数为一，保证FIFO执行所有任务。<br/>
         * 无界队列（队列最大为Integer.MAX_VALUE）,瞬间请求过大，会有OOM风险。
         *
         */
        Executors.newFixedThreadPool(2, new MyThreadFactory());
        Executors.newSingleThreadExecutor(new MyThreadFactory());
        threadPoolExecutor = new ThreadPoolExecutor(2, 2,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(),
                new MyThreadFactory());

        /**
         * 周期和定时线程池<br/>
         * 同时执行的线程最大为Integer.MAX_VALUE 存在OOM风险。可以定时和周期执行任务。
         *
         */
        Executors.newScheduledThreadPool(2);

        /**
         *
         * 并行度线程池<br/>
         *
         * 使用多个队列，并行度默认为cpu数量。
         *
         *
         */
        Executors.newWorkStealingPool();

 

 

 

ThreadPoolExecutor  构造器参数

 

 /**
     * 线程池<br/>
     * 线程池ThreadPoolExecutor的参数使用说明<br/>
     * {@code corePoolSize}核心线程数，一直维持在线程池中，即使他们是空闲的，除非设置了 {@code allowCoreThreadTimeOut}<br/>
     * <p>
     * {@code maximumPoolSize}最大线程数，线程池中允许的最大线程数。最大线程数大于等于核心线程数。<br/>
     * <p>
     * {@code keepAliveTime} 空闲线程存活时间， 当线程数大于核心线程时，这个时间是空闲线程终止之前等待新的任务的最大时间 。<br/>
     * <p>
     * {@code unit} 空闲线程存活时间的单位<br/>
     * <p>
     * {@code workQueue} 工作队列，当工作线程大于核心线程时，新的任务加入工作队列中。<br/>
     * <p>
     * {@code threadFactory} 线程工厂，线程池通过线程工厂创建新的线程。<br/>
     * <p>
     * {@code handle} 拒绝策略，当达到最大线程数也就是达到线程边界和队列容量最大值时，会用到拒绝策略。<br/>
     */

 

 

 

 

ThreadPoolExecutor execute执行过程

/**
 *  ThreadPoolExecutor execute
 */
public void execute(Runnable command) {
    //判空
    if (command == null)
        throw new NullPointerException();
    //获取执行器计数
    int c = ctl.get();
    //活动线程与核心线程比较，小于侧创建新的线程。
    if (workerCountOf(c) < corePoolSize) {
        //添加任务
        if (addWorker(command, true))
            //添加成功退出
            return;
        c = ctl.get();
    }

    //如果执行器未关闭，添加到队列中
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        //如果执行器关闭，删除队列
        if (! isRunning(recheck) && remove(command))
            //调用拒绝策略
            reject(command);
        //无活动线程，创建新的线程
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    //无法创建新的任务
    else if (!addWorker(command, false))
        //调用拒绝策略
        reject(command);
}

 

ThreadPoolExecutor RejectedExecutionHandler 拒绝策略

根据业务需求选择合适的拒绝策略，如果ThreadPoolExecutor自带的四种拒绝策略无法满足需求，也可以实现RejectedExecutionHandler接口自定义拒绝策略。

public static class CallerRunsPolicy implements RejectedExecutionHandler {
        public CallerRunsPolicy() {
        }
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            //执行器没有关闭，则直接调用任务的run方法。
            if (!e.isShutdown()) {
                r.run();
            }
            //执行器关闭，抛弃任务。
        }
    }
    public static class AbortPolicy implements RejectedExecutionHandler {
        public AbortPolicy() {
        }
        /**
         * 直接抛出RejectedExecutionException这个异常。
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                    " rejected from " +
                    e.toString());
        }
    }
    public static class DiscardPolicy implements RejectedExecutionHandler {
        public DiscardPolicy() {
        }
        /**
         * 什么也不做直接抛弃任务
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }
    public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        public DiscardOldestPolicy() {
        }
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            //线程执行器未关闭
            if (!e.isShutdown()) {
                //删除队列最老的任务
                e.getQueue().poll();
                //把任务交给执行器执行。
                e.execute(r);
            }
            //线程执行器关闭，直接抛弃任务。
        }
    }