线程池addWorker执行流程（添加工作线程）

//添加工作线程
private boolean addWorker(Runnable firstTask, boolean core) {
//    对线程池状态的判断以及对工作线程数量的判断
//    外层for循环的标识
        retry:
        for (;;) {
//            获取ctl值
            int c = ctl.get();
//            拿到线程池的状态
            int rs = runStateOf(c);

            // 如果当前线程状态不是RUNNING，再次做后续判断，查看当前任务是否可以不处理
            if (rs >= SHUTDOWN &&
//                    线程池状态为SHUTDOWN，并且任务为空，并且工作队列不为空
//                    如果同时满足了这三个要求，那就是要处理工作队列当前中的任务
                    ! (rs == SHUTDOWN &&
                            firstTask == null &&
                            ! workQueue.isEmpty()))
//                只要不是RUNNING状态，不处理新任务
//                如果是SHUTDOWN状态,并且满足了之前addWorker(null,false),并且工作队列有任务时,需要创建线程
                return false;

            for (;;) {
//                获取当前工作线程数
                int wc = workerCountOf(c);
//                判断工作线程是否大于最大值
                if (wc >= CAPACITY ||
//                        如果是核心线程,是否大于设置的corePoolSize
//                        如果是非核心线程,是否大于maximumPoolSize
                        wc >= (core ? corePoolSize : maximumPoolSize))
//                    当前工作线程已经达到最大值
                    return false;
//                以CAS对工作线程数+1,如果成功,直接跳出外层for循环
                if (compareAndIncrementWorkerCount(c))
//                    跳出外层for循环
                    break retry;
//                重新获取ctl
                c = ctl.get();  // Re-read ctl
//                基于新获取的ctl拿到线程池状态,判断和之前的rs状态是否一致
                if (runStateOf(c) != rs)
//                    说明并发操作导致线程池状态变化,需要重新判断状态
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

//        添加工作线程并启动工作线程
//    工作线程是否启动
        boolean workerStarted = false;
//        工作线程是否添加
        boolean workerAdded = false;
//        Worker就是工作线程
        ThreadPoolExecutor.Worker w = null;
        try {
//            new Worker构建工作线程，将任务扔到了Worker中
            w = new ThreadPoolExecutor.Worker(firstTask);
//            拿到了Worker中绑定的Thread线程
            final Thread t = w.thread;
            if (t != null) {
//                加锁
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
//                   重新获取ctl，拿到线程池的状态
                    int rs = runStateOf(ctl.get());
//                   如果满足线程池状态为RUNNING，就添加工作线程
                    if (rs < SHUTDOWN ||
//                            如果线程池状态为SHUTDOWN并且传入的任务为null
                            (rs == SHUTDOWN && firstTask == null)) {
//                        开始添加工作线程
//                        判断当前线程是否 处于run状态（健壮性判断）
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
//                        将构建好的worker对象添加到worklers
                        workers.add(w);
//                        获取工作线程个数
                        int s = workers.size();
//                        记录工作线程最大值，如果现在的工作线程数大于历史最大值
                        if (s > largestPoolSize)
                            largestPoolSize = s;
//                        将工作线程添加的标识设置为true
                        workerAdded = true;
                    }
                } finally {
//                    释放锁
                    mainLock.unlock();
                }
//              只要添加工作线程成功，启动线程
                if (workerAdded) {
                    t.start();
//                    将工作线程启动的标识设置为true
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
//                如果启动工作线程失败，做的补救操作
//                判断之前创建工作线程是否成功，如果成功，将workers中当前工作线程移除
//                将工作线程数减一
//                尝试将线程池状态变为TIDYING
                addWorkerFailed(w);
        }
        return workerStarted;
    }