线程池-线程池源码详解

在ThreadPoolExecutor的属性定义中频繁地用位移运算来表示线程池状态，位移运算是改变当前值的一种高效手段，包括左移和右移。下面从属性定义开始阅读ThreadPoolExecutor的源码。

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    //Integer 共有32位，最右边29位表示工作线程数，最左边3位表示线程池状态。
    //注：简单的说，3个二进制位可以表示从0-7的8个不同的数值（第1处）
    private static final int COUNT_BITS = Integer.SIZE - 3;
    //000-11111111111111111111111111111,类似于子网掩码，用于位的与运算
    //得到最左边的3位，还是右边的29位
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // runState is stored in the high-order bits
    //用左边3位，实现5种线程池状态（在左边3位之后加入中画线有助于理解）
    //111-00000000000000000000000000000,十进制值：-563,870,912
    //此状态便是线程池能够接受的新任务
    private static final int RUNNING    = -1 << COUNT_BITS;

    //000-00000000000000000000000000000,十进制值：0
    //此状态不再接受新任务，但可以继续执行队列中的任务
    private static final int SHUTDOWN   =  0 << COUNT_BITS;

    //001-00000000000000000000000000000,十进制值：563,870,912
    //此状态全面拒绝，并终止正在处理的任务
    private static final int STOP       =  1 << COUNT_BITS;

    //010-00000000000000000000000000000,十进制值：1073，741，824
    //此状态表示所有的任务已经被终止
    private static final int TIDYING    =  2 << COUNT_BITS;

    //011-00000000000000000000000000000
    //此状态表示已清理完现场
    private static final int TERMINATED =  3 << COUNT_BITS;

    // Packing and unpacking ctl
    // 与运算，比如 001-00000000000000000000000100011,表示67个工作线程
    // 掩码取反    111-00000000000000000000000000000，即得到最左边3位 001
    // 表示线程处于stop 状态
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    //同理掩码 000-11111111111111111111111111111，得到右边29位，即工作线程数
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    //把左边3位与右边29位按或运算，合并成一个值
    private static int ctlOf(int rs, int wc) { return rs | wc; }

第一处说明，线程池状态用高3位表示，其中包括了符号位。五种状态的十进制值按小道大依次排序为：

RUNNING<SHUTDOWN<STOP<TIDYING<TERMINATED

这样设计的好处是可以通过比较值的大小来确定线程池的状态，例如程序中经常出现isRuning的判断。

   private static boolean isRunning(int c) {
        return c < SHUTDOWN;
    }

我们都知道Exexutor 接口有且只有一个方法execute，通过参数传入待执行线程对象。下面分析ThreadPoolExecutor关于execute的实现。

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

        //返回包含线程数及线程池状态的Integer类型数值
        int c = ctl.get();
        //如果工作线程数小于核心线程数，则创建线程任务并执行
        if (workerCountOf(c) < corePoolSize) {
            //addWorker 是另一个极为重要的方法，见下一段源码分析（第1处）
            if (addWorker(command, true))
                return;
            //如果创建失败，防止外部已经在线程池中加入新任务，重新获取一下
            c = ctl.get();
        }
        // 只有线程池处于RUNNING 状态，才执行后半句：置入队列
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            // 如果线程池不是 RUNNING 状态 则将刚加入队列的任务移除
            if (! isRunning(recheck) && remove(command))
                reject(command);
            //如果之前的线程已经被消费完，新建一个线程
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //核心池和队列都已经满，尝试创建一个新线程
        else if (!addWorker(command, false))
            //如果addWorker返回false，即创建失败，则唤醒拒绝策略（第2处）
            reject(command);
    }

第2处 发生拒绝的原因有两个（1）线程池状态非Runing (2)等待队列已满。

下面继续分析addWorker 源码。

/**
     * 根据当前线程池状态，检查是否可以添加新的任务线程，如果可以则创建并启动任务
     * 如果一切正常则返回true。返回false 的可能如下：
     * 1.线程池没有处于RUNNING状态
     * 2.线程工程创建新的任务线程失败
     * @param firstTask 外部启动线程池时需要构造的第一个线程，它是线程的母体
     * @param core 新增工作线程时的判断指标，解释如下
     *             true：表示新增线程时，需要判断当前RUNNING 状态的线程是否少于corePoolsize
     *             false:表示新增线程时，需要判断当前RUNNING 状态的线程是否少于maxmemPoolsize
     * @return
     */
    private boolean addWorker(Runnable firstTask, boolean core) {
        //不需要任务预定义的语法标签，响应下文的continue retry.快速退出多层嵌套循环（第1处）
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c); // 当前线程池状态

            // Check if queue empty only if necessary.
            // 这条语句等价：rs >= SHUTDOWN && (rs != SHUTDOWN || firstTask != null ||workQueue.isEmpty())
            // 满足下列条件则直接返回false，线程创建失败:
            // rs > SHUTDOWN:STOP || TIDYING || TERMINATED 此时不再接受新的任务，且所有任务执行结束
            // rs = SHUTDOWN:firtTask != null 此时不再接受任务，但是仍然会执行队列中的任务
            // rs = SHUTDOWN:firtTask == null见execute方法的addWorker(null, false)，任务为null && 队列为空
            // 最后一种情况也就是说SHUTDONW状态下，如果队列不为空还得接着往下执行，为什么？add一个null任务目的到底是什么？
            // 看execute方法只有workCount==0的时候firstTask才会为null结合这里的条件就是线程池SHUTDOWN了不再接受新任务
            // 但是此时队列不为空，那么还得创建线程把任务给执行完才行。

            //第2处
            if (rs >= SHUTDOWN &&
                    ! (rs == SHUTDOWN &&
                            firstTask == null &&
                            ! workQueue.isEmpty()))
                return false;

            // 走到这的情形：
            // 1.线程池状态为RUNNING
            // 2.SHUTDOWN状态，但队列中还有任务需要执行
            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                        wc >= (core ? corePoolSize : maximumPoolSize)) // 最大线程数不能超过2^29,否则影响左边3位的线程池状态值
                    return false;
                //（第3处）
                if (compareAndIncrementWorkerCount(c)) //当前活动线程数+1（第3处） 原子操作递增workCount
                    break retry; //操作成功跳出重试循环
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs) //如果线程池的状态发生变化则重试（第5处）
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        //开始创建工作线程
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            //利用worker构造方法中的线程池工厂创建线程，并封装成工作线程worker对象
            w = new Worker(firstTask);
            //注意这是worker 中属性对象thread （第6处）
            final Thread t = w.thread;
            if (t != null) {
                //对ThreadExecutor 的敏感操作时，都需要持有主锁，避免在添加和启动线程时被干扰。
                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;// 更新largestPoolSize
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                // 启动新添加的线程，这个线程首先执行firstTask，然后不停的从队列中取任务执行
                // 当等待keepAlieTime还没有任务执行则该线程结束。见runWoker和getTask方法的代码。
                if (workerAdded) {
                    t.start(); //最终执行的是ThreadPoolExecutor的runWoker方法 并非线程池execute 的command参数指向的线程
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }