项目中用到的线程池

private static Log logger = LogFactory.get();
    // 核心线程数
    private static final int corePoolSize = 1;
    // 最大线程数
    private static final int maximumPoolSize = 200;
    // 线程空闲时间
    private static final int keepAliveTime = 200;
    private static final int capacity = 1;

    /**
     * 处理线程池
     * @Title
     * @Description
     * @Date 16:51 2019/10/9
     * @Param (核心线程数,最大线程数,线程空闲时间,时间单位 默认为秒,数组阻塞队列)

     *
     * @return
     **/
    /**
     * 阻塞队列
     * 数组阻塞队列(ArrayBlockingQueue) ：底层基于数组的有界阻塞队列，初始化时需要指定队列大小；
     * 链表阻塞队列(LinkedBlockingQueue) ：以链表来存储元素，理论上只要存储空间够大，就是无界的；
     * 同步阻塞队列(SynchronousQueue)：队列中不存储元素，队列中放入元素后，只有该元素被消费完成，才能重修放入元素；
     * 优先级无界阻塞队列(PriorityBlockingQueue)：底层基于数组的无界队列，支持队列内部按照指定元素排序；
     * 链表阻塞双端队列(LinkedBlockingDeque)：底层基于链表的有界双端阻塞队列；
     * 延迟无界阻塞队列(DelayQueue)：底层是基于数组的无界延迟队列，它是在PriorityQueue基础上实现的，先按延迟优先级排序，延迟时间短的排在队列前面；
     * 链表阻塞队列与同步阻塞队列结合(LinkedTransferQueue)：基于链表的无界阻塞队列；
     */
    /**
     * 拒绝策略
     * AbortPolicy - 丢弃任务，并抛出拒绝执行 RejectedExecutionException 异常信息。线程池默认的拒绝策略。必须处理好抛出的异常，否则会打断当前的执行流程，影响后续的任务执行
     * CallerRunsPolicy - 当触发拒绝策略，只要线程池没有关闭的话，则使用调用线程直接运行任务。一般并发比较小，性能要求不高，不允许失败。但是，由于调用者自己运行任务，如果任务提交速度过快，可能导致程序阻塞，性能效率上必然的损失较大
     * DiscardPolicy - 直接丢弃，其他啥都没有
     * DiscardOldestPolicy - 当触发拒绝策略，只要线程池没有关闭的话，丢弃阻塞队列 workQueue 中最老的一个任务，并将新任务加入
     */

    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.MILLISECONDS,
            new ArrayBlockingQueue<>(capacity));


    public static void main(String[] args) {
        TaskConfig task = parseConfig("task", TaskConfig.class);
        List<SourceConfig> sourceConfigs = parseConfigs("source",SourceConfig.class);
        List<PluginConfig> pluginConfigs = parseConfigs("plugin", PluginConfig.class);

        if(task==null){
            logger.error("任务配置为空！");
            return;
        }

        logger.info("任务配置信息初始化！{}", JSON.toJSONString(task));
        logger.info("数据源信息初始化！{}", JSON.toJSONString(sourceConfigs));
        logger.info("插件信息初始化！{}", JSON.toJSONString(pluginConfigs));

        logger.info("{}处理程序开始执行！",task.getName());
        while (true){

            List<TaskEntity> taskList = new ArrayList<>();
            try{
                Map<String,String> taskMap = JedisClusterUtil.hgetAll(task.getRedis_key());
                if(taskMap!=null&&taskMap.size()>0){
                    taskMap.values().forEach(taskStr-> taskList.add(JSONObject.parseObject(taskStr, TaskEntity.class)));
                    taskList.sort(Comparator.comparing(TaskEntity::getLevel).thenComparing(TaskEntity::getOption_date).reversed());

                    for (int i = 0; i < taskList.size(); i++) {
                        TaskEntity taskBean = taskList.get(i);
                        if(taskBean.getStatus()==0){
                            DataProcessRunnable thread = new DataProcessRunnable(taskBean,task,sourceConfigs,pluginConfigs);
                            while (true){
                                System.out.println("当前活跃线程数:"+executor.getActiveCount());
                                // 当前线程数是否小于核心线程数
                                if(executor.getActiveCount()<corePoolSize){
                                    executor.execute(thread);
                                    break;
                                }else{
                                    logger.info("当前线程数已满！休眠10s后重试！");
                                    Thread.sleep(10000);
                                }
                            }
                        }
                    }
                }else{
                    logger.info("本次处理任务列表为空！");
                }
            }catch (Exception e){
                e.getMessage();
                try {
                    logger.error("任务发布异常！休眠10s后重试",e);
                    Thread.sleep(10000);
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }

            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }