public class ThreadPoolUtils {

    private static final Logger logger = LoggerFactory.getLogger(ThreadPoolUtils.class);
    /**
     * 线程池维护线程的最少数量
     */
    private static final int SIZE_CORE_POOL = 4;
    /**
     * 线程池维护线程的最大数量
     */
    private static final int SIZE_MAX_POOL = 8;

    /**
     * 禁止手动初始化
     */
    private ThreadPoolUtils() {}

    public static void printPoolInfo() {

        logger.info("当前线程Pool的数量 = [{}]",Singleton.SINGLETON.getThreadPool().getPoolSize());
        logger.info("当前task的数量 = [{}]",Singleton.SINGLETON.getThreadPool().getTaskCount());
        logger.info("当前执行task的数量 = [{}]",Singleton.SINGLETON.getThreadPool().getActiveCount());
        logger.info("当前完成task的数量 = [{}]",Singleton.SINGLETON.getThreadPool().getCompletedTaskCount());
    }

    /**
     * 通过枚举创建单例对象
     */
    private enum Singleton {
        /**
         * 线程池单例
         */
        SINGLETON;
        private ThreadPoolExecutor threadPool;
        private ScheduledExecutorService service;
        Singleton() {
            // 为线程命名
            ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
                    .setNameFormat("线程池工具类-pool-%d").build();
            // 创建线程池1
            threadPool = new ThreadPoolExecutor(
                    SIZE_CORE_POOL,
                    SIZE_MAX_POOL,
                    10L,
                    TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>(),
                    namedThreadFactory);
            // 创建线程池2
            service  = Executors.newScheduledThreadPool(4);
        }

        /**
         * 返回单例对象
         */
        public ThreadPoolExecutor getThreadPool() {
            return threadPool;
        }

        public ScheduledExecutorService getScheduledThreadPool() {
            return service;
        }

    }

    /**
     * 向池中添加任务
     * 单次执行
     * @param task
     */
    public static void addExecuteTask(Runnable task) {
        if (task != null) {

            ThreadPoolExecutor threadPoolExecutor = Singleton.SINGLETON.getThreadPool();
            threadPoolExecutor.execute(task);
        }
    }
    public static void addScheduleTask(Runnable task) {
        Singleton.SINGLETON.getScheduledThreadPool().scheduleWithFixedDelay(task, 5, 3, TimeUnit.SECONDS);

    }


}

// 创建线程池1
threadPool = new ThreadPoolExecutor(
	SIZE_CORE_POOL,
	SIZE_MAX_POOL,
	10L,
	TimeUnit.MILLISECONDS,
	new LinkedBlockingQueue<Runnable>(),
	namedThreadFactory);

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    /*
     * Proceed in 3 steps:
     *
     * 1. If fewer than corePoolSize threads are running, try to
     * start a new thread with the given command as its first
     * task.  The call to addWorker atomically checks runState and
     * workerCount, and so prevents false alarms that would add
     * threads when it shouldn't, by returning false.
     *
     * 2. If a task can be successfully queued, then we still need
     * to double-check whether we should have added a thread
     * (because existing ones died since last checking) or that
     * the pool shut down since entry into this method. So we
     * recheck state and if necessary roll back the enqueuing if
     * stopped, or start a new thread if there are none.
     *
     * 3. If we cannot queue task, then we try to add a new
     * thread.  If it fails, we know we are shut down or saturated
     * and so reject the task.
     */
    int c = ctl.get();
    // 1. 如果当前线程数 小于 corePoolSize，则尝试添加新线程
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 2. 尝试向workQueue添加队列（offer方法在workQueue没有容量时，添加失败），线程已经存在不会创建新的线程，如果不存在则创建新的线程。
    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);
    }
    // 3. 添加新线程，此处会比较maximumPoolSize，如果大于maximumPoolSize，则会使用饱和策略
    else if (!addWorker(command, false))
        reject(command);
}

public class TestThreadPool {

    private static ThreadFactory tf = new ThreadFactoryBuilder()
            .setNameFormat("factory-pool-%d").build();
    private static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(4, 8, 10L,
            TimeUnit.MINUTES, new LinkedBlockingQueue<>(50), tf);
    public static void main(String[] args) throws InterruptedException {
				System.out.println("================start================");
        for (int i = 0; i<100; i++) {
            threadPoolExecutor.execute(new Task(String.valueOf(i)));
        }
        System.out.println("================end================");
    }
}
class Task implements Runnable {
    private static final Logger logger = LoggerFactory.getLogger(TestThreadPool.class);

    private String name;
    public Task(String name) {
        this.name = "[ " + name + " ]";
    }

    @Override
    public void run() {
        logger.info(name + "只要干不死，就往死里干，奥利干！！");
        // System.out.println(name + "奥利给！！");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

@Override
public void run() {
	// logger.info(name + "只要干不死，就往死里干，奥利干！！");
	System.out.println(name + "奥利给！！");
}

@Override
public void run() {
	// logger.info(name + "只要干不死，就往死里干，奥利干！！");
	// System.out.println(name + "奥利给！！");
	logger.info(name + "奥利给！！");
}