并发编程学习笔记（三十四、线程池源码四，execute方法分析）

目录：

• execute()
• addWorker()

execute()

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    /*
     * 处理过程分为以下三步：
     *
     * 1. 线程池线程数小于corePoolSize：
     * 则创建新的核心线程执行任务，command=新线程的第一个执行的任务。
     * 否则进入步骤2。
     *
     * 2. 若任务可以成功进入阻塞队列，则重新检查线程池状态。
     * 如果线程池已经停止了，则将刚刚入队的任务做处理。
     * 如果线程池内没有线程了，则创建一个新的线程
     *
     * 3. 如果任务入队失败，则创建一个新的非核心线程。
     * 如果创建非核心线程失败了，则线程池可能已经关闭或饱和了。
     * 因此需要拒绝这个任务。
     */
    int c = ctl.get();
    // 工作线程小于corePoolSize
    if (workerCountOf(c) < corePoolSize) {
        // 创建新的核心线程执行任务
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 重新检查线程状态，并调用offer方法入队
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 线程处于非running状态，并且成功删除刚刚入队的任务
        if (!isRunning(recheck) && remove(command))
            // 执行reject方法，拒绝此次提交的任务
            reject(command);
        // 线程池内没有任务了
        else if (workerCountOf(recheck) == 0)
            // 创建一个非核心线程任务
            addWorker(null, false);
    }
    // 线程处于非running状态，或是running状态但入队失败了
    // 尝试通过addWorker方法创建一个非核心线程
    // 创建失败则拒绝任务
    else if (!addWorker(command, false))
        reject(command);
}

addWorker()

private boolean addWorker(Runnable firstTask, boolean core) {
    // 外层循环标记
    retry:
    for (;;) {
        int c = ctl.get();
        // 获取运行状态
        int rs = runStateOf(c);

        // 当线程池状态为SHUTDOWN、STOP、TIDYING、TERMINATED且
        // 状态不为SHUTDOWN 或 firstTask!=null 或 队列为空时返回false
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            // 添加工作线程失败
            return false;

        for (;;) {
            // 获取工作线程数
            int wc = workerCountOf(c);
            // 工作线程数大于最大容量
            // 或在创建核心线程时，工作线程数大于核心线程数
            // 或在创建非核心线程时，工作线程数大于最大线程数
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                // 添加工作线程失败
                return false;
            // CAS自增工作线程数，成功则调到最外层循环
            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 {
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            // 使用可重入锁加锁
            mainLock.lock();
            try {
                // 获取线程池工作状态
                int rs = runStateOf(ctl.get());

                // rs < SHUTDOWN：RUNNING
                // rs == SHUTDOWN && firstTask为空
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    // 添加此工作线程
                    workers.add(w);
                    int s = workers.size();
                    // 如果工作线程数超过largestPoolSize
                    if (s > largestPoolSize)
                        // 则设置largestPoolSize=5
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                // 当满足workerAdded时，启动线程逻辑
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

其实大多数的逻辑都是对线程状态的卡控，当满足workerAdded时，启动线程逻辑（thread.start()）。