自定义线程池

package com.szbd.core.threadpool;

import java.util.List;
import java.util.Objects;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 普通任务线程池
 * @author szbd
 *
 */
public class NormalTaskThreadPool {
    //核心线程数量
    private int corePoolSize = 10;
    //最大线程数量
    private int maxPoolSize = 20;
    //最大空闲时间
    private long keepAliveTime = 5L;
    //等待任务队列
    private BlockingQueue<Runnable> workQueue = null;
    //拒绝策略
    private RejectedExecutionHandler rejectHandler = null;
    //线程池
    private ThreadPoolExecutor threadPoolExecutor = null;
    //守护线程
    private Thread deamonThread = null;
    //休眠10秒
    private long sleepTime = 10000L;
    
    /**
     * 初始化线程池
     */
    public void initThreadPool(int maxPoolSize) {
        workQueue = new LinkedBlockingQueue<Runnable>();
        rejectHandler = new ThreadPoolExecutor.AbortPolicy();
        
        this.maxPoolSize = maxPoolSize;
        
        //无界队列，maxPoolSize会无效
        if(workQueue instanceof LinkedBlockingQueue) {
            threadPoolExecutor = new ThreadPoolExecutor(
                    this.maxPoolSize, this.maxPoolSize, this.keepAliveTime, TimeUnit.SECONDS, this.workQueue, this.rejectHandler);
        } else {
            threadPoolExecutor = new ThreadPoolExecutor(
                    this.corePoolSize, this.maxPoolSize, this.keepAliveTime, TimeUnit.SECONDS, this.workQueue, this.rejectHandler);
        }
        
        deamonThread = new Thread(() -> watch());
        deamonThread.start();
    }
    
    /**
     * 添加一个任务
     * @param task
     */
    public void addTask(Runnable task) {
        threadPoolExecutor.submit(task);
        printThreadPoolInfo();
    }
    
    /**
     * 添加任务列表
     * @param tasks
     */
    public void addTasks(List<Runnable> tasks) {
        if(Objects.nonNull(tasks) && tasks.size() > 0) {
            for(Runnable task : tasks) {
                threadPoolExecutor.submit(task);
            }
            printThreadPoolInfo();
        }
    }
    
    /**
     * 监控线程池
     */
    private void watch() {
        long count = 0L;
        while(true) {
            try {
                //每隔2分钟打印一次线程池信息
                if(count%120 == 0) {
                    printThreadPoolInfo();
                }
                Thread.sleep(sleepTime);
                count += 10;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 打印线程池信息
     */
    private void printThreadPoolInfo() {
        StringBuffer strb = new StringBuffer();
        strb.append("普通任务线程池，最大同时运行线程数量：").append(threadPoolExecutor.getMaximumPoolSize());
        strb.append("，正在运行线程数量：").append(threadPoolExecutor.getActiveCount());
        strb.append("，待执行队列任务数量：").append(workQueue.size());
        strb.append("，已执行任务数量：").append(threadPoolExecutor.getCompletedTaskCount());
        
        System.out.println(strb.toString());
    }

}