java线程池原理解析

五一假期大雄看了一本《java并发编程艺术》，了解了线程池的基本工作流程，竟然发现线程池工作原理和互联网公司运作模式十分相似。

线程池处理流程

原理解析

互联网公司与线程池的关系

这里用一个比喻来描述一下线程池，中间有一些名词你可能不是太清楚，后边源码解析的部分会讲到。

你可以把线程池看作是一个研发部门，研发部门有很多程序员（Worker), 他们在一个大办公室里（HashSet workers)。程序员干不完的需求（Runnable/Callable)放在需求池（workQueue）里排队。每个研发部都配置有骨干程序员数量（corePoolSize）和最大能容纳的程序员数量（maximumPoolSize）。具体要做的任务就是产品的需求。

new 一个线程池相当于创建了一个研发部，创建研发部时需要指定骨干程序员数量，最大能容纳的程序员数量，需求池用哪种（BlockingQueue）,如果忙不过来的需求怎么给产品回复（拒绝策略）等等内容。刚开始这个研发部一个程序员也没有。

当产品给这个研发部提一个需求时（当然肯定不会只提一个，他们会不断的提需求。这里以提一个需求为例）

首先会看骨干程序员招聘满了没。

如果没满，会招聘一个骨干程序员，招聘进来就让他不停的工作（很残酷啊），干完刚派过来的任务他会主动在需求池找下一个需求来做（好员工），如果需求池没有需求了，他就停止工作了，然后研发部会把他裁掉，如果裁掉后发现骨干程序员数量不够了，就会再招聘一个程序员。裁掉后，要是骨干程序员数量还够就不招聘了。

如果骨干程序员数量满了，就看需求池满没满，如果需求池没满，就把需求扔进需求池里；如果需求池满了，就看程序员数量有没有达到上限，如果达到了，就对产品说，这个需求我们做不了，没资源；如果没达到，就招聘一个程序员，招聘进来就让他不停的工作，干完刚派过来的需求他会主动到需求池找下一个任务来做，如果需求池没有任务了，他就停止工作了，然后研发部会把他裁掉，如果裁掉后发现骨干程序员数量不够了，就会再招聘一个程序员。裁掉后，要是骨干程序员数量还够就不招聘了。

源码解析

首先是worker（程序员）

Worker被装在一个HashSet（workers）里边， 他是用来执行任务的，他们的职责就是不断的从workQueue里边取任务，然后执行。当workQueue（需求池）里边拿不到任务，或者线程池达到特定状态，worker就会从workers里边移走（被裁）。

下边是Worker源码，移除了非关键的东西

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{

    // 标识这个任务是在哪个线程运行
    final Thread thread;
    Runnable firstTask;
    // 完成了几个任务
    volatile long completedTasks;

    Worker(Runnable firstTask) {
        // 阻止中断，知道runWorker执行
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        // 直接用你提供的线程工厂搞个线程出来
        this.thread = getThreadFactory().newThread(this);
    }

    // 调用ThreadPoolExecutor里边的runWorker方法
    public void run() {
        runWorker(this);
    }

    // 以下这些是AQS相关的东西

    // 0代表没有加锁
    // 1代表加锁了
    protected boolean isHeldExclusively() {
        return getState() != 0;
    }

    protected boolean tryAcquire(int unused) {
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }

    protected boolean tryRelease(int unused) {
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
    }

    public void lock()        { acquire(1); }
    public boolean tryLock()  { return tryAcquire(1); }
    public void unlock()      { release(1); }
    public boolean isLocked() { return isHeldExclusively(); }

    void interruptIfStarted() {
        Thread t;
        if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
            try {
                t.interrupt();
            } catch (SecurityException ignore) {
            }
        }
    }
}

Worker实现了Runnable接口，所以他是个任务，有run方法；同时有继承了AQS，所以他也是一把锁。

下边是提交任务的过程

提交任务有submit和execute, submit就是首先将Callable或者Runnable包装成FutureTask，然后调用execute, 所以核心是分析execute

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    // 这个c里边有两个信息，一个是现在有多少worker, 另一个是现在线程池的状态是啥
    // workerCountOf方法就是从里边提取 worker的数量的
    int c = ctl.get();
    if (workerCountOf(c) < corePoolSize) { // 当前worker的数量比需要的核心线程数少
        // 加worker去执行,加成功就完事了，也就是说只要worker比核心线程数少，就会创建worker
        // 不管现在核心线程是否在工作，也不管workQueue是不是满的
        // addWorker的第二个参数表示是不是要加核心线程（或者叫核心worker)
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 当前worker达到或超过了核心线程数，或者加worker失败了，才会走下边的流程
    // worker已经比核心线程数多了

    // 如果 线程池没有shutdown的话 
    // 就尝试将任务加到workQueue里边，工作队列入队成功的话再往里边走
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))
            // 再次检查状态如果线程池要停了，那么就拒绝任务，并且把worker从工作队列扔掉
            reject(command);
        else if (workerCountOf(recheck) == 0)
            // 如果没有worker的话(说明没加进去，这种场景我没想到是什么情况)，加一个worker
            addWorker(null, false);
        // 其他情况，丢到工作队列就不用管了，等着worker去处理
    }
    // 如果队列满了加失败了，或者线程池状态不满足了，就尝试加普通worker(非核心线程)
    else if (!addWorker(command, false))
        // 加失败了就拒绝任务
        // 失败一方面可能是worker数量已经达到你的给的maximumPoolSize
        // 另一方面，可能是检查到线程池的状态不对了
        reject(command);
}

可以发现execute方法就是完成了上边说的“线程池处理流程”这个图里描述的过程。 大雄看到这里还有几个疑问，一个是Woker是如何创建并加入workers的，一个是worker是如何启动的，再就是worker是如何运行的

生活还要继续

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

        // 做一些校验，线程池的状态要满足一定条件
        // 而且得提交任务过来，再就是workQueue不能是空的
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
                firstTask == null &&
                ! workQueue.isEmpty()))
            return false;

        for (;;) {
            int wc = workerCountOf(c);
            // 看你是要创建核心worker还是普通worker
            // 核心看超没超过corePoolSize, 普通看超没超过maximumPoolSize
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            if (compareAndIncrementWorkerCount(c))
            // 增加worker数量失败就在来
                break retry;
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)
                // 中途线程池状态发生变化了
                continue retry;
        }
    }

    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        // worker就是这么创建的
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            // 加worker是要加全局锁的
            mainLock.lock();
            try {
                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) {
                // worker是在这里启动的
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

这段代码解决了 Woker是如何创建并加入workers的以及worker是如何启动的的问题。

addWorker做的核心工作就是，创建worker, 启动worker, 在创建之前还会做一些校验。调用了worker里边线程的start后就要等待cpu调度执行worker的run方法了。

public void run() {
    runWorker(this);
}

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        // task是创建worker带进去的任务，会先执行他，然后从workQueue里边取
        // 如果没有的话跳出去
        while (task != null || (task = getTask()) != null) {
            w.lock();   // 首先加锁，如果不加锁，可能几个线程提交的任务同时进来了，会导致一些共享状态出问题

            // 做一些状态的校验
            if ((runStateAtLeast(ctl.get(), STOP) ||
                    (Thread.interrupted() &&
                    runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                // 执行任务前调用一下beforeExecute， 默认是空的
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    // 这个跟我们平时理解的Runnable还不一样，可以体会下，他这个run就是一个普通的方法
                    // 他直接调run是要执行任务，线程的start只是把worker里边的那个run跑起来了
                    task.run();
                } catch (RuntimeException x) {
                    thrown = x; throw x;
                } catch (Error x) {
                    thrown = x; throw x;
                } catch (Throwable x) {
                    thrown = x; throw new Error(x);
                } finally {
                    // 执行完了调一下，里边可以拿到异常
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        // 从while跳出来表明没有任务可以执行了
        processWorkerExit(w, completedAbruptly);
    }
}

这个也比较容易，就是不断的从workQueue取任务，执行，直到没任务了跳出来。接下来就是worker如何被销毁的问题了

private void processWorkerExit(Worker w, boolean completedAbruptly) {
    if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
        decrementWorkerCount();

    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        completedTaskCount += w.completedTasks;
        // 移除掉worker（裁员）
        workers.remove(w);
    } finally {
        mainLock.unlock();
    }

    tryTerminate();

    int c = ctl.get();
    if (runStateLessThan(c, STOP)) {
        if (!completedAbruptly) {
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            if (min == 0 && ! workQueue.isEmpty())
                min = 1;
            // 比核心线程数多的话，执行完的Worker直接移除就好
            if (workerCountOf(c) >= min)
                return; // replacement not needed
        }
        // 小于核心线程数就会再加个Worker, 让他继续等待接收任务（招人）
        addWorker(null, false);
    }
}

直接从workers里边移除worker, 移除后如果worker数量比核心线程数还少，就再加个worker, 否则不加。

一些体会

看源码一定不要过分纠结细节，就像这个线程池，我看网上很多文章去算那几个位运算的十进制数，感觉是在浪费时间，没有抓住重点。

当然这也不是绝对的（似乎说的矛盾了），一些细节的设计还是非常精妙值得学习的。还是这个位运算，为什么只用一个int表示线程池状态和worker的数量呢。

要多多联想，还是这个位运算，他是不是和读写锁用一个int既表示写状态又表示读状态十分相似。Worker继承AQS，是否能让你想起AQS的种种。

总之，个人觉得第一遍看是一定不能沉溺于细节的，他会让你迷惘和丧失信心；第二遍、第三遍可以关注一下细节，感受大师级的设计的美妙之处。当然笔者仅仅粗略看了一遍（逃~）

最后

大雄五一假期阅读了《java并发编程艺术》这本书，整理了一本gitbook笔记（还没写完），需要的同学可以扫描文末二维码关注“大雄和你一起学编程”公众号，后台回复我爱java领取。这本gitbook还没彻底完成，所以可能还有些小错误。未来会大约每两天推送其中的一篇文章。

如下是这本gitbook的目录截图