线程池原理

/**
 * firstTask参数用于表示怎么获取线程处理的任务，true为传入的任务，false表示从阻塞队列获取任务
 * core参数为true表示在新增线程时会判断当前活动线程数是否少于corePoolSize，
 * false表示新增线程前需要判断当前活动线程数是否少于maximumPoolSize
 */
private boolean addWorker(Runnable firstTask, boolean core) {
    // 内嵌循环，通过CAS worker + 1
    retry:
    for (; ; ) {
        // 获取当前线程池状态与线程数
        int c = ctl.get();
        // 获取当前线程状态
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        /**
         * 这个if判断
         * 如果线程池处于SHUTDOWN，STOP，TIDYING，TERMINATED的时候，则表示此时不再接收新任务；
         * 接着判断以下3个条件，只要有1个不满足，则返回false：
         * 1. rs == SHUTDOWN，这时表示关闭状态，不再接受新提交的任务，但却可以继续处理阻塞队列中已保存的任务
         * 2. firsTask为空
         * 3. 阻塞队列不为空
         *
         * 首先考虑rs == SHUTDOWN的情况
         * 这种情况下不会接受新提交的任务，所以在firstTask不为空的时候会返回false；
         * 然后，如果firstTask为空，并且workQueue也为空，则返回false，
         * 因为队列中已经没有任务了，不需要再添加线程了
         */
        if (rs >= SHUTDOWN &&
                !(rs == SHUTDOWN &&
                        // 不在接受新的任务
                        firstTask == null &&
                        // 队列中已经没有任务了，不需要再添加线程了
                        !workQueue.isEmpty()))
            return false;
        // 增加工作线程数
        for (; ; ) {
            // 线程数量
            int wc = workerCountOf(c);
            // 如果当前线程数大于线程最大上限CAPACITY  return false
            // 创建核心线程则与 corePoolSize 比较，否则与 maximumPoolSize 比较
            if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            // 尝试增加workerCount，如果成功，则跳出第一个for循环
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }

    // 创建一个新的线程并执行
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        final ReentrantLock mainLock = this.mainLock;
        // 新建线程，将线程封装成Worker
        w = new Worker(firstTask);
        // 每一个Worker对象都会创建一个线程
        final Thread t = w.thread;
        if (t != null) {
            // 将任务添加到workers Queue中
            mainLock.lock();
            try {
                // Recheck while holding lock.
                // Back out on ThreadFactory failure or if
                // shut down before lock acquired.
                int c = ctl.get();
                // 线程池状态
                int rs = runStateOf(c);

                // rs < SHUTDOWN表示是RUNNING状态；
                if (rs < SHUTDOWN ||
                        // rs是SHUTDOWN状态并且firstTask为null，向线程池中添加线程。
                        // 因为在SHUTDOWN时不会在添加新的任务，但还是会执行workQueue中的任务
                        (rs == SHUTDOWN && firstTask == null)) {
                    // 当前线程已经启动，抛出异常
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    // workers是一个HashSet<Worker>
                    workers.add(w);
                    // 设置最大的池大小largestPoolSize，workerAdded设置为true
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            // 启动线程
            if (workerAdded) {
                // 启动时会调用Worker类中的run方法，Worker本身实现了Runnable接口，所以一个Worker类型的对象也是一个线程
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        // 线程启动失败
        if (!workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}