jdk线程池（三）——源码解析

上一篇文章中讲述了任务提交、线程池中线程的创建或任务进入队列的源码，本节将继续讲解后续线程池中线程如何运行处理任务的过程。源码承接上一篇的runWorker方法，其具体内容如下：

final void runWorker(Worker w) {
        //1、获取当前线程和初始化任务，在提取了worker中初始任务后，将其变量赋值为空，从而其在初始任务执行后可以去阻塞队列中消费
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        //2、创建Worker时，将AQS中的状态设置为-1，从而使得Worker中的线程不能被中断，这里释放锁，将AQS的状态设置为0，使得当前线程可以设置中断。
        w.unlock(); 
        //3、异常结束标识，只有在任务消费正常执行时，才会设置标识为false
        boolean completedAbruptly = true;
        try {
            //4、while循环消费初始任务和队列中任务，正常情况下阻塞队列为空才退出
            while (task != null || (task = getTask()) != null) {
                //4.1、当前worker加锁，保证worker中线程处理任务时相关属性不被调用
                w.lock();
                //4.2、可以简单理解为如果线程池状态大于等于stop，但当前线程未中断，则设置当前线程中断位
                if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted())
                    wt.interrupt();
                try {
                    //4.3、任务执行前调用的特定方法，一般可以通过实现该方法来扩展线程池功能
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        //4.4、调用任务的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 {
                        //4.5、任务执行后调用的特定方法，一般可以通过实现该方法来扩展线程池功能
                        afterExecute(task, thrown);
                    }
                } finally {
                    //4.6、任务变量设为空，便于GC和接收新任务，并递增当前worker执行完的任务数，最后释放当前worker的锁。
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            //5、正常流程下，代码流会到这一步设置异常终止状态为false，从而再最后的worker退出时执行对应的代码
            completedAbruptly = false;
        } finally {
            //6、根据worker线程池线程的处理任务情况来处理worker
            processWorkerExit(w, completedAbruptly);
        }
    }

以上便是主要的runWorker流程，其中还有两个比较核心的方法没有讲，一个是getTask获取任务方法，一个是worker处理线程退出时执行的方法，下面接着讲一下：

private Runnable getTask() {
        //1、阻塞队列拉取任务是否超时标识
        boolean timedOut = false; 
        //2、for循环从阻塞队列获取任务，直至获取到任务或者因以下情况退出（1、工作线程（即worker）数超过最大线程数 2、线程池为停止状态 3、线程池为shutdown关闭态且任务队列为空 4、超时等待从阻塞队列获取任务）
        for (;;) {
            //2.1、获取线程池全局控制变量，并提取出线程池的运行状态
            int c = ctl.get();
            int rs = runStateOf(c);
            //2.2、线程池为停止状态 或 线程池为shutdown关闭态且任务队列为空 工作线程数减一，并返回空
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                //2.2.1、因为addWorker方法创建Worker时CAS增加了工作线程数，此时线程池为停止状态或shutdown关闭态且任务队列为空，则该工作线程（Worker）不再需要，所以此处要以CAS方式减少工作线程数（仅仅是减少了计数，这里还没有关闭当前worker）。
                decrementWorkerCount();
                return null;
            }
            //2.3、获取线程池中的线程数
            int wc = workerCountOf(c);
            //2.4、根据线程池是否允许核心线程超时以及当前线程池中线程数判断是否有线程（即worker）达到超时去除的条件
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            //2.5、如果线程池中线程数大于最大线程数或达到超时去除线程条件，且工作线程至少大于1或阻塞队列为空。则CAS减少线程数（仅仅是减少了计数，这里还没有关闭当前worker）并返回空任务，
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                //2.5.1、如果CAS减少线程数失败，表明线程池中线程可能有所变化，所以重新循环获取任务。
                continue;
            }

            try {
                //2.6、根据是否有线程达到超时退出的条件，采用不用的获取方法。如果有达到了条件，则调用poll限时获取方法，方便线程长时间获取不到任务时及时返回对应标识，从而使得线程池消除多出的线程（这里是设置了超时标志，在上面的2.5步骤中根据该标志和相关条件返回空任务，最后在processWorkerExit方法中去除多余线程）。如果没有达到条件，则直接调用阻塞方法take，直至获取到任务。
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                //2.7、任务不为空，直接返回
                if (r != null)
                    return r;
                //2.8、任务为空，表明超时未取到任务，此时设置对应标识，方便2.5步骤中判断
                timedOut = true;
            } catch (InterruptedException retry) {
                //2.9、当前捕获异常为中断异常，表明线程被中断，此时重新进入循环(这一步不是很懂，如果有知道的，希望可以留言告知，谢谢)
                timedOut = false;
            }
        }
    }

上面就是获取任务的源码流程，下面来看一下最后的退出处理方法：

private void processWorkerExit(Worker w, boolean completedAbruptly) {
        //1、如果是异常终止，说明没有在线程池全局控制变量中减少线程数，这里再此进行处理一下
        if (completedAbruptly) 
            decrementWorkerCount();
        //2、处理退出流程时，涉及到workers工作集合变量的使用，这里为了并发安全（比如说有的线程遍历workers集合操作时，不加锁就会和下面的remove操作冲突），获取锁后再进行后续操作
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            completedTaskCount += w.completedTasks;
            workers.remove(w);
        } finally {
            mainLock.unlock();
        }
        //3、能到这个方法表明任务队列可能已经为空，所以尝试终止线程池
        tryTerminate();
        //4、获取线程池全局控制变量
        int c = ctl.get();
        //5、如果当前状态小于停止态
        if (runStateLessThan(c, STOP)) {
            //5.1、如果不是异常终止
            if (!completedAbruptly) {
                //5.1.1、获取线程池中线程理论最小数
                int min = allowCoreThreadTimeOut ? 0: corePoolSize;
                //5.1.2、如果队列不为空，且最小值为0，则重新赋值最小值（队列不为空，表明任务没执行完，所以至少需要一个线程进行处理）
                if (min == 0 && ! workQueue.isEmpty())
                    min = 1;
                //5.1.3、工作线程数大于需要的最小线程数，不要额外补充线程，所以通过return跳过下面的addWorker方法。
                if (workerCountOf(c) >= min)
                    return; // replacement not needed
            }
            //5.2、能到这一步，表明实际线程数小于最小线程数，所以通过addWorker补充工作线程。这里是否为核心任务参数设置为false，是因为不确定allowCoreThreadTimeOut设置的是什么，所以不好根据核心线程数判断是否新增线程。所以这里设置了参数为false后，会根据maximumPoolSize过滤是否新增线程。而且核心线程和普通线程也并没有什么区别。
            addWorker(null, false);
        }
    }

退出的大致流程了解了，不过这个方法中还有一个比较有趣的方法没有进行讲解，那就是tryTerminate方法，这是工作线程退出处理时比较关键的一环，所以这里也源码追踪一下：

final void tryTerminate() {
        //for循环避免CAS失败的情况
        for (;;) {
            //1、获取全局控制变量
            int c = ctl.get();
            //2、如果线程池正在运行 或 大于TIDYING状态（说明已经终断过） 或处于shutdown状态但工作队列不为空，则跳出此次终断
            if (isRunning(c) ||
                runStateAtLeast(c, TIDYING) ||
                (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
                return;
            //3、经过上一步过滤，能到这里表明当前为stop状态或者shutdown状态但队列为空，此时如果线程数不等于0，表明还有线程在运行，此处主动调用中断方法，中断一个线程。并跳出此次终断
            if (workerCountOf(c) != 0) { 
                //3.1、遍历workers集合，设置第一个未中断且能成功获取锁的线程为中断态
                interruptIdleWorkers(ONLY_ONE);
                //3.2、中断后跳出此次终断。这里在中断后直接跳出是因为线程池中还有线程没有处理，所以还不能执行后续的terminated操作
                return;
            }
            //4、获取主锁
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                //5、能到这一步表明线程池中队列为空，线程数也为空，所以设置线程池状态为TIDYING（这也是第2步中为什么说大于TIDYING状态表示线程池已经终断过的原因）
                if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                    try {
                        //5.1、TIDYING状态设置成功后，调用terminated()方法标识正式进入terminate状态
                        terminated();
                    } finally {
                        //5.2、设置线程池为terminated状态
                        ctl.set(ctlOf(TERMINATED, 0));
                        //5.3、唤醒awaitTermination方法中等待终断的线程
                        termination.signalAll();
                    }
                    return;
                }
            } finally {
                mainLock.unlock();
            }
        }
    }

至此，线程池的创建、任务的添加、工作线程的创建、退出时线程的销毁和线程池的关闭已经讲解完了。本来想再写一个汇总的文字说明，但是各种分支判断比较多，所以就没写，感觉有需要的时候还是看代码比较直接，当然主要还是我个人文笔不行。