// 线程池构造方法
public ThreadPoolExecutor(int corePoolSize, // 核心线程数
                          int maximumPoolSize, // 最大线程数
                          long keepAliveTime, // 存活时间
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue, // 排队队列
                          ThreadFactory threadFactory, // 创建线程的工作类
                          RejectedExecutionHandler handler) // 线程数满，队列满时具体任务策略
{
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

// 报警线程池
ExecutorService executorService = new ThreadPoolExecutor(3, 5, 60,
    TimeUnit.SECONDS,
    new LinkedBlockingDeque<Runnable>(10),
    new DefaultThreadFactory("test-thread"),
    new ThreadPoolExecutor.CallerRunsPolicy());
    
    
// 线程创建工厂，主要设置为非守护线程，指定线程名，设置优先级
// 关于这个工厂类，推荐看netty的实现
public class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    public DefaultThreadFactory(String poolName) {
        if (null == poolName) {
            poolName = "pool";
        }
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
        namePrefix = poolName + poolNumber.getAndIncrement() + "-thread-";
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

// 创建一个固定大小的线程池
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

public static ExecutorService newWorkStealingPool(int parallelism) {
    return new ForkJoinPool
        (parallelism,
         ForkJoinPool.defaultForkJoinWorkerThreadFactory,
         null, true);
}

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

//高3位111，低29位为0 该状态下线程池会接收新提交任务和执行队列任务
private static final int RUNNING    = -1 << COUNT_BITS;

//高3位000，低29位为0 该状态下线程池不再接收新任务，但还会继续执行队列任务
private static final int SHUTDOWN   =  0 << COUNT_BITS;

//高3位001，低29位为0 该状态下线程池不再接收新任务，不会再执行队列任务，并会中断正在执行中的任务
private static final int STOP       =  1 << COUNT_BITS;

//高3位010，低29位为0 该状态下线程池的所有任务都被终止，工作线程数为0，期间会调用钩子方法terminated()
private static final int TIDYING    =  2 << COUNT_BITS;

//高3位011，低29位为0 该状态下表明线程池terminated()方法已经调用完成
private static final int TERMINATED =  3 << COUNT_BITS;

/**
 * 1.若实际工作线程数 < 核心工作线程数，会尝试创建一个工作线程去执行该
 * 任务，即该command会作为该线程的第一个任务，即第一个firstTask
 * 
 * 2.若任务入队成功，仍需要执行双重校验，原因有两点：
 *      - 第一个是去确认是否需要新建一个工作线程，因为可能存在
 *        在上次检查后已经死亡died的工作线程
 *      - 第二个是可能在进入该方法后线程池被关闭了，
 *        比如执行shutdown()
 *   因此需要再次检查state状态，并分别处理以上两种情况：
 *      - 若线程池中已无可用工作线程了，则需要新建一个工作线程 
 *      - 若线程池已被关闭，则需要回滚入队列(若有必要)
 * 
 * 3.若任务入队失败(比如队列已满)，则需要新建一个工作线程； 
 *      - 若新建线程失败，说明线程池已停止或者已饱和，必须执行拒绝策略
 */
public void execute(Runnable command) {

    //新任务不允许为空，空则抛出NPE
    if (command == null)
        throw new NullPointerException();

    // ctl 为线程池状态控制器，用于保证线程池状态和工作线程数 
    // 低29位为工作线程数量，高3位为线程池状态
    int c = ctl.get();

    /**
     * case1：当实际工作线程数 < 核心工作线程数时
     * 执行方案：会创建一个新的工作线程去执行该任务
     * 注意：此时即使有其他空闲的工作线程也还是会新增工作线程，
     *      直到达到核心工作线程数为止
     */
    if (workerCountOf(c) < corePoolSize) {

        /**
         * 新增工作线程，true表示要对比的是核心工作线程数
         * 一旦新增成功就开始执行当前任务
         * 期间也会通过自旋获取队列任务进行执行
         */
        if (addWorker(command, true))
            return;

        /**
         * 需要重新获取控制器状态，说明新增线程失败
         * 线程失败的原因可能有两种：
         *  - 1.线程池已被关闭，非RUNNING状态的线程池是不允许接收新任务的
         *  - 2.并发时，假如都通过了workerCountOf(c) < corePoolSize校验，但其他线程
         *      可能会在addWorker前先创建出线程，导致workerCountOf(c) >= corePoolSize，
         *      即实际工作线程数 >= 核心工作线程数，此时需要进入case2
         */
        c = ctl.get();
    }

    /**
     * case2：当实际工作线程数>=核心线程数时，新提交任务需要入队
     * 执行方案：一旦入队成功，仍需要处理线程池状态突变和工作线程死亡的情况
     */
    if (isRunning(c) && workQueue.offer(command)) {

        //双重校验
        int recheck = ctl.get();

        /**
         * recheck的目的是为了防止线程池状态的突变 - 即被关闭
         * 一旦线程池非RUNNING状态时，除了从队列中移除该任务(回滚)外
         * 还需要执行任务拒绝策略处理新提交的任务
         */
        if (!isRunning(recheck) && remove(command))
            //执行任务拒绝策略
            reject(command);

        /**
         * 若线程池还是RUNNING状态 或 
         *  队列移除失败(可能正好被一个工作线程拿到处理了)
         * 此时需要确保至少有一个工作线程还可以干活
         * 补充一句：之所有无须与核心工作线程数或最大线程数相比，而只是比较0的原因是
         *          只要保证有一个工作线程可以干活就行，它会自动去获取任务
         */
        else if (workerCountOf(recheck) == 0)
            /**
             * 若工作线程都已死亡，需要新增一个工作线程去干活
             * 死亡原因可能是线程超时或者异常等等复杂情况
             *
             * 第一个参数为null指的是传入一个空任务，
             * 目的是创建一个新工作线程去处理队列中的剩余任务
             * 第二个参数为false目的是提示可以扩容到最大工作线程数
             */
            addWorker(null, false);
    }

    /**
     * case3：一旦线程池被关闭 或者 新任务入队失败(队列已满)
     * 执行方案：会尝试创建一个新的工作线程，并允许扩容到最大工作线程数
     * 注意：一旦创建失败，比如超过最大工作线程数，需要执行任务拒绝策略
     */
    else if (!addWorker(command, false))
        //执行任务拒绝策略
        reject(command);
}

/**
 * 新增工作线程需要遵守线程池控制状态规定和边界限制
 *
 * @param core core为true时允许扩容到核心工作线程数，否则为最大工作线程数
 * @return 新增成功返回true，失败返回false
 */
private boolean addWorker(Runnable firstTask, boolean core) {

    //重试标签
    retry:

    /***
     * 外部自旋 -> 目的是确认是否能够新增工作线程
     * 允许新增线程的条件有两个：
     *   1.满足线程池状态条件 -> 条件一
     *   2.实际工作线程满足数量边界条件 -> 条件二
     * 不满足条件时会直接返回false，表示新增工作线程失败
     */
    for (;;) {

        //读取原子控制量 - 包含workerCount(实际工作线程数)和runState(线程池状态)
        int c = ctl.get();

        //读取线程池状态
        int rs = runStateOf(c);

        /**
         * 条件一.判断是否满足线程池状态条件
         *  1.只有两种情况允许新增线程：
         *    1.1 线程池状态==RUNNING
         *    1.2 线程池状态==SHUTDOWN且firstTask为null同时队列非空
         *
         *  2.线程池状态>=SHUTDOWN时不允许接收新任务，具体如下：
         *    2.1 线程池状态>SHUTDOWN，即为STOP、TIDYING、TERMINATED
         *    2.2 线程池状态==SHUTDOWN，但firstTask非空
         *    2.3 线程池状态==SHUTDOWN且firstTask为空，但队列为空
         *  补充：针对1.2、2.2、2.3的情况具体请参加后面的"小问答"环节
         */
        if (rs >= SHUTDOWN &&
            !(rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty()))
            return false;

        /***
         * 内部自旋 -> 条件二.判断实际工作线程数是否满足数量边界条件
         *   -数量边界条件满足会对尝试workerCount实现CAS自增，否则新增失败
         *   -当CAS失败时会再次重新判断是否满足新增条件：
         *       1.若此期间线程池状态突变(被关闭)，重新判断线程池状态条件和数量边界条件
        *        2.若此期间线程池状态一致，则只需重新判断数量边界条件
        */
        for (;;) {

            //读取实际工作线程数
            int wc = workerCountOf(c);

            /**
             * 新增工作线程会因两种实际工作线程数超标情况而失败：
             *  1.实际工作线程数 >= 最大容量
             *  2.实际工作线程数 > 工作线程比较边界数(当前最大扩容数)
             *   -若core = true，比较边界数 = 核心工作线程数
             *   -若core = false，比较边界数 = 最大工作线程数
             */
            if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize))
                return false;

            /**
             * 实际工作线程计数CAS自增:
             *   1.一旦成功直接退出整个retry循环，表明新增条件都满足
             *   2.因并发竞争导致CAS更新失败的原因有三种: 
             *      2.1 线程池刚好已新增一个工作线程
             *        -> 计数增加，只需重新判断数量边界条件
             *      2.2 刚好其他工作线程运行期发生错误或因超时被回收
             *        -> 计数减少，只需重新判断数量边界条件
             *      2.3 刚好线程池被关闭 
             *        -> 计数减少，工作线程被回收，
             *           需重新判断线程池状态条件和数量边界条件
             */
            if (compareAndIncrementWorkerCount(c))
                break retry;

            //重新读取原子控制量 -> 原因是在此期间可能线程池被关闭了
            c = ctl.get();

            /**
             * 快速检测是否发生线程池状态突变
             *  1.若状态突变，重新判断线程池状态条件和数量边界条件
             *  2.若状态一致，则只需重新判断数量边界条件
             */
            if (runStateOf(c) != rs)
                continue retry;
        }
    }

    /**
     * 这里是addWorker方法的一个分割线
     * 前面的代码的作用是决定了线程池接受还是拒绝新增工作线程
     * 后面的代码的作用是真正开始新增工作线程并封装成Worker接着执行后续操作
     * PS:虽然笔者觉得这个方法其实可以拆分成两个方法的(在break retry的位置)
     */

    //记录新增的工作线程是否开始工作
    boolean workerStarted = false;

    //记录新增的worker是否成功添加到workers集合中
    boolean workerAdded = false;

    Worker w = null;
    try {

        //将新提交的任务和当前线程封装成一个Worker
        w = new Worker(firstTask);

        //获取新创建的实际工作线程
        final Thread t = w.thread;

        /**
         * 检测是否有可执行任务的线程，即是否成功创建了新的工作线程
         *   1.若存在，则选择执行任务
         *   2.若不存在，则需要执行addWorkerFailed()方法
         */
        if (t != null) {

            /**
             * 新增工作线程需要加全局锁
             * 目的是为了确保安全更新workers集合和largestPoolSize
             */
            final ReentrantLock mainLock = this.mainLock;

            mainLock.lock();
            try {

                /**
                 * 获得全局锁后，需再次检测当前线程池状态
                 * 原因在于预防两种非法情况：
                 *  1.线程工厂创建线程失败
                 *  2.在锁被获取之前，线程池就被关闭了
                 */
                int rs = runStateOf(ctl.get());

                /**
                 * 只有两种情况是允许添加work进入works集合的
                 * 也只有进入workers集合后才是真正的工作线程，并开始执行任务
                 *  1.线程池状态为RUNNING(即rs<SHUTDOWN)
                 *  2.线程池状态为SHUTDOWN且传入一个空任务
                 *  (理由参见：小问答之快速检测线程池状态?) 
                 */
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {

                    /**
                     * 若线程处于活动状态时，说明线程已启动，需要立即抛出"线程状态非法异常"
                     * 原因是线程是在后面才被start的，已被start的不允许再被添加到workers集合中
                     * 换句话说该方法新增线程时，而线程是新的，本身应该是初始状态(new)
                     * 可能出现的场景：自定义线程工厂newThread有可能会提前启动线程
                     */
                    if (t.isAlive())
                        throw new IllegalThreadStateException();

                    //由于加锁，所以可以放心的加入集合
                    workers.add(w);
                    int s = workers.size();

                    //更新最大工作线程数，由于持有锁，所以无需CAS
                    if (s > largestPoolSize)
                        largestPoolSize = s;

                    //确认新建的worker已被添加到workers集合中  
                    workerAdded = true;
                }
            } finally {

                //千万不要忘记主动解锁
                mainLock.unlock();
            }

            /**
             * 一旦新建工作线程被加入工作线程集合中，就意味着其可以开始干活了
             * 有心的您肯定发现在线程start之前已经释放锁了
             * 原因在于一旦workerAdded为true时，说明锁的目的已经达到
             * 根据最小化锁作用域的原则，线程执行任务无须加锁，这是种优化
             * 也希望您在使用锁时尽量保证锁的作用域最小化
             */
            if (workerAdded) {

                /**
                 * 启动线程，开始干活啦
                 * 若您看过笔者的"并发番@Thread一文通"肯定知道start()后，
                 * 一旦线程初始化完成便会立即调用run()方法
                 */
                t.start();

                //确认该工作线程开始干活了
                workerStarted = true;
            }
        }
    } finally {

        //若新建工作线程失败或新建工作线程后没有成功执行，需要做新增失败处理
        if (!workerStarted)
            addWorkerFailed(w);
    }

    //返回结果表明新建的工作线程是否已启动执行
    return workerStarted;
}

java.util.concurrent.ThreadPoolExecutor#ThreadPoolExecutor(int, int, long,
    java.util.concurrent.TimeUnit, 
    java.util.concurrent.BlockingQueue<java.lang.Runnable>,
    java.util.concurrent.ThreadFactory,
    java.util.concurrent.RejectedExecutionHandler)

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 3, TimeUnit.SECONDS, new LinkedBlockingQueue(), 
    //我们自定义一个线程工厂和重写线程的setUncaughtExceptionHandler方法
    new ThreadFactory() {
        final AtomicInteger threadNumber = new AtomicInteger(1);
        public Thread newThread(Runnable r) {
            Thread thread = new Thread(Thread.currentThread().getThreadGroup(), r, "thread-"
                    + (threadNumber.getAndIncrement()));
            thread.setUncaughtExceptionHandler((t,e) -> System.out.println(e));
            return thread;
        }
});