多线程笔记（三）线程池 ThreadPoolExecutor

1. ctl：将 workerCount（工作线程的数量）和线程池的状态放在一个 int 中保存

    在 ctolOf 方法中实现

private static int ctlOf(int rs, int wc) { return rs | wc; }

    作用：并不是节省空间，而是为了保持线程池状态和运行状态的统一，放在一个变量里，可以保证这两部分同时修改
2. 五种状态，需要三个 bit 来表示，所以高 3 位表示状态，剩下的 29 位表示工作线程的数量，因此线程池中工作线程的最大数量为 $2^29−1$

    也就是 ThreadPoolExecutor.CAPACITY（高三位为 0，低 29 位为 1）

private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    计算工作线程的数量：workerCountOf 方法。和 CAPACITY 做 & 运算，由于 CAPACITY 的低 29 位都为 1，所以可以取出工作线程的数量

private static int workerCountOf(int c)  { return c & CAPACITY; }

    获取线程池状态：要取 ctl 的高三位的值，因此先把 CAPACITY 取反，然后和 ctl 做 & 运算

private static int runStateOf(int c)     { return c & ~CAPACITY; }

3. execute 方法

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();

    // 获取当前线程池的状态
    int c = ctl.get();
    // 当工作线程数 < 核心线程池容量时，添加工作线程去执行任务
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        // 重新获取状态
        c = ctl.get();
    }
    // 达到核心池上限，尝试加入缓存队列
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 再次检查线程池状态
        if (! isRunning(recheck) && remove(command))// 线程池没有在运行，将任务移出队列，并执行拒绝策略
            reject(command);
        else if (workerCountOf(recheck) == 0)// 线程池中没有线程，需要创建新的线程，传入 null 是因为创建的线程去队列里取任务，不需要指定执行的任务
            addWorker(null, false);
    }
    else if (!addWorker(command, false)) // 缓存队列已满，尝试创建新的线程
        reject(command);
}

4. addWorker 方法

 

private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) { // loop1
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        // 此处 if 判断为 False 只有两种情况：rs 为 running（也就是 < shutdown），当然可以继续添加线程；还有就是虽然线程池已经 shutdown，但是不会添加新的任务（firstTask == null），同时队列里还有任务，也就是(rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())，其他情况都是 True，需要停止添加线程，返回 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 使 workCount 加 1，成功则退出 loop1，继续下面的代码
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
            // CAS 操作失败，重新检查状态，如果线程池状态改变，进行外部循环（loop1）
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
            // 线程池状态不变的话，继续内部循环，尝试使 workCount 加 1
        }
    }

    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 {
                // Recheck while holding lock.
                // Back out on ThreadFactory failure or if
                // shut down before lock acquired.
                int rs = runStateOf(ctl.get());
                
                // 检查线程池状态
                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();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                // 启动线程
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}