《java.util.concurrent 包源码阅读》11 线程池系列之ThreadPoolExecutor 第一部分

先来看ThreadPoolExecutor的execute方法，这个方法能体现出一个Task被加入到线程池之后都发生了什么：

    public void execute(Runnable command) {        if (command == null)            throw new NullPointerException();        /* 如果运行中的worker线程数少于设定的常驻线程数，增加worker线程，把task分配给新建的worker线程 */        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)                addWorker(null, false);        }        // 如果任务数超过了现有worker线程的承受范围，尝试新建worker线程        // 如果无法添加新的worker线程，则会拒绝该任务        else if (!addWorker(command, false))            reject(command);    }

在执行任务时，需要经常检查线程池的状态，那么接下来说说线程池是如何进行状态控制的。上面的代码有个成员变量叫做ctl，它用于标记线程池状态和worker线程的数量，是一个AutomaticInteger对象。

    PRivate final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

ctl是一个32位的整数，最高的3位表示状态：

111为running，

000为shutdown，

001为stop，

010为tidying，

011为ternimated。

因此状态值就是这三位加上29个0，因此running的值是个负整数（最高位为1），其他状态都是正整数，后面判断状态会比较值的大小时会用到这点。

剩下的29位表示worker线程的数量（因此最大允许的线程数就是2的29方减1）。

这里是说说这几个状态的意义，这几个状态发生的顺序正好就是上面列出的顺序：

running表示正常运行状态

shutdown状态意味着发出了一个shutdown信号，类似于你点击了windows的关机按钮

stop表示shutdown信号收到，等于windows响应了这个信号，发出正在关机的信息

tidying发生在stop之后做出的响应，表示这个时候在清理一些资源，

ternimated发生在tidying完成之后，表示关闭完成。

接着来看添加一个worker线程时都发生了什么：

    private boolean addWorker(Runnable firstTask, boolean core) {        retry:        for (;;) {            int c = ctl.get();            int rs = runStateOf(c);            // 返回false的情况：            // 1. rs>shutdown，即shutdown和running以外的状态            // 2. shutdown的状态            //     1）firstTask不为null，即有task分配            //     2）没有task，但是workQueue（等待任务队列）为空            if (rs >= SHUTDOWN &&                ! (rs == SHUTDOWN &&                   firstTask == null &&                   ! workQueue.isEmpty()))                return false;            for (;;) {                // 1. 如果没有设定线程数的限制，worker线程数不能大于最大值（2的29次方-1）                // 2. 如果是固定尺寸的线程池，不能大于固定尺寸                // 3. 如果是可扩展的线程池，不能大于规定的线程数的上限                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;                loop            }        }        // 新建worker线程        Worker w = new Worker(firstTask);        Thread t = w.thread;        final ReentrantLock mainLock = this.mainLock;        mainLock.lock();        try {            int c = ctl.get();            int rs = runStateOf(c);            // 检查以下任一状态是否出现：            // 1. 创建线程失败            // 2. rs>shutdown，即shutdown和running以外的状态            // 3. rs==shutdown，有任务分配            if (t == null ||                (rs >= SHUTDOWN &&                 ! (rs == SHUTDOWN &&                    firstTask == null))) {                decrementWorkerCount();                tryTerminate();                return false;            }            workers.add(w);            int s = workers.size();            if (s > largestPoolSize)                largestPoolSize = s;        } finally {            mainLock.unlock();        }        t.start();        // 这里考虑一种极少出现的情况，如果worker线程调用start没有完成时，        // 线程池进入Stop状态，这个时候会调用Thread#interrupt中断每个        // worker线程，但是 interrupt对没有start的线程不一定起作用，这样        // 就会漏掉了对这个thread的interrupt，因此在worker线程start之后        // 检查以下，如果stop了，而这个线程却没有被interrupt，补上这个漏掉        // 的interrupt。        if (runStateOf(ctl.get()) == STOP && ! t.isInterrupted())            t.interrupt();        return true;    }

这篇文章主要讲线程池如何处理任务，下一篇文章将会讲worker线程是如何工作的。