JAVA线程池源码系列——1、线程池如何执行任务

最新推荐文章于 2024-08-15 10:46:07 发布

吃饭睡觉胖胖胖

最新推荐文章于 2024-08-15 10:46:07 发布

阅读量1k

点赞数 2

分类专栏： JAVA线程池文章标签： java 多线程队列

本文链接：https://blog.csdn.net/meiyongdesan/article/details/106482331

版权

JAVA线程池专栏收录该内容

2 篇文章 0 订阅

订阅专栏

概述

之前我写了一篇博客，系统的介绍了线程池相关知识。感兴趣的读者可以点击这里查看之前的博客。

最近我打算实现一个简单的线程池，在实现过程遇到很多问题，从中发现很多之前没有搞懂的知识点。为了查缺补漏，我打算整理一遍线程池核心功能的完整源码。

线程池如何执行任务

本篇主要介绍线程池执行一个任务的全过程。为了便于理解，我打算按照源码执行顺序展开，其中每个方法尽可能通过流程图的方式展示。

在阅读本篇博客前，需要你对线程池有一个大概的了解，本篇不会具体解释某个属性的作用，如果对线程池本身还不太熟悉的话，建议先点击概述中的链接初步了解一下。

1、execute(Runnable command)

进入正题，线程池无论通过哪种方式执行任务，最终都会调用 execute() 方法。下面我们直接给出 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)
            addWorker(null, false);
    }
    else if (!addWorker(command, false))
        reject(command);
}

关于该方法的逻辑，我们直接通过以下流程图介绍：

在这里插入图片描述
首先就流程图中，几个我认为比较迷惑的点先列出来并给出我的理解：

为什么在任务入队后，还需要判断线程池状态是否停止，并尝试删除任务呢？

答：这里实际上是做了一个复检的操作，为的是防止在任务入队期间线程池停止。
为什么要分两种线程？一种以被执行任务为参数，一种以null为参数？

答：这里的任务参数表示 第一个执行的任务。也就是说，该线程启动后有一个初始任务。如果任务入队的话，就不需要创建线程默认执行，因为它迟早会从队列中取出并执行。
核心线程和非核心的区别有哪些？

答：我认为两者本身没有区别，只是在创建线程过程中，核心线程和非核心线程进行不同的逻辑判断，核心线程根据核心线程数判断，非核心线程根据所有线程数判断。

总结：就我个人理解，execute() 方法主要判断是否需要创建 Worker对象。而在线程池中，Worker类也就是线程工作类，也就是说该方法主要判断当前任务是否需要创建新线程来执行。

根据阅读上述代码，我们会发现，只有以下三种情况才会创建新的线程：

线程池中工作线程数量小于 核心线程数量 时，创建 核心线程。
线程池中阻塞队列不为空，工作线程数量等于0时，创建 非核心线程。
创建核心线程失败，任务入队失败时，创建 非核心线程。

而这三种情况对应的实际场景依次分别是：

核心线程数量不够，补充新的核心线程执行当前任务
线程池中没有线程，并且阻塞队列中存在未执行的任务，将任务入队，按照队列顺序依次执行
核心线程已满，阻塞队列已满，创建非核心线程执行当前任务

当然上述只是线程执行的第一步，下面我们来阅读具体创建工作线程的代码：

2、addWorker(Runnable firstTask, boolean core)

线程池执行 execute() 方法后，最终都要通过 addWorker() 方法创建的线程执行。下面我们直接给出 addWork() 方法的源代码：

private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
        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;
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)
                continue retry;
        }
    }
    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 {
                int rs = runStateOf(ctl.get());
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive())
                        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;
}

关于该方法的逻辑，我们也通过流程图的方式展开：

添加工作线程流程图
首先我们解释流程图中的 特殊情况 ：线程池处于 ShutDown状态，当前任务为空，并且阻塞队列不为空时。这也就对应上述 execute() 方法的第二种情况，唯一区别是，execute() 方法执行时线程池还处于 Running 状态，而这里线程池已经处于ShutDown状态。

通过这里也可以反映出线程池策略：线程池停止后不会处理新方法，但缓存队列中的方法还会执行。

关于上述流程图，我也列举出部分疑问我和理解：

上述代码中，为什么要加解锁？

答：加解锁期间，主要是为了处理部分线程不安全的变量。如：workers 采用 HashSet 数据结构，largestPoolSize 是 int 类型的，这两个全局变量都是线程不安全的。
上述代码中，创建线程后，为什么要判断线程是否启动？

答：关于这个问题我也不能理解：新创建的线程在没有启动时，isAlive() 方法一定会返回 false，也就是说该判断一定不同通过。我怀疑该方法是为了确定创建对象期间是否出错，也就是初始化thread属性期间没有出现异常。

总结：addWorker() 方法主要完成创建工作线程，并启动该工作线程。有且仅当工作线程创建成功并启动时返回 True。该方法在 execute() 方法的基础上，增加了判断线程数量的操作，其余都是一些维护线程池属性的操作。除此之外，它还实现了非Running状态，拒绝执行任务的逻辑。

execute()方法和 addWorker() 方法都是在主线程层面调用线程池执行任务，下面我们具体看一下工作线程是如何执行任务，也就是Worker类的源码。

3、Worker 类

Worker类是线程池中用来封装工作线程的核心类，我们直接看它的源码：

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{
    private static final long serialVersionUID = 6138294804551838833L;

    final Thread thread;
    Runnable firstTask;
    volatile long completedTasks;

    Worker(Runnable firstTask) {
        setState(-1);
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }
    
    public void run() {
        runWorker(this);
    }
    
	// 略
}

首先该类继承 AbstractQueuedSynchronizer 类，简化部分同步操作。其实也很容易猜到，这里简化的是每个任务执行所获取和释放的锁定。

其次该类实现了 Runnable 接口，也就是说可以将该类对象作为参数创建线程，启动线程来执行该类的run() 方法。

最后该类有两个重要的属性：thread 和 firstTask。thread 表示工作线程本身，firstTask 表示该工作线程的首任务。在构造方法中，通过Worker对象本身作为参数创建线程 thread，而该 thread 又是 Worker 对象的属性。我们在启动该Worker对象的thread属性时，实际上就是执行Worker对象的run()方法，也就是线程体。

关于这样做的好处我是这样理解的：

线程池可以从外部维护 Worker对象，而不是 Thread 对象，易于管理
可以通过Worker对象实现部分方法，通过调用这些方法操作线程，而不是通过thread对象
可以在Worker对象中维护属性记录线程的状态，不用每次调用Thread方法判断

下面我们来看 runWorker() 方法的源码，熟悉线程体都做了什么

4、runWorker(Worker w)

所有工作线程最终都会走到 runWorker() 方法来执行任务，这里我直接贴出源码：

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock();
    boolean completedAbruptly = true;
    try {
        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(wt, task);
                Throwable thrown = null;
                try {
                    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 {
        processWorkerExit(w, completedAbruptly);
    }
}

上述代码我们依旧通过流程图的形式展开，如下所示（流程图中部分非关键逻辑可能存在错误，例如线程调用interrupt()方法并不会立即停止）：执行任务流程
这个方法的核心功能就是告诉我们，工作线程通过直接执行Runnable对象方法的run方法执行任务。

其中 执行前期操作 和 执行后期操作 都可能产生异常，方法体内可以做异常抛出等操作。

需要注意的一点是：有且仅当getTask()方法抛出异常时，才会导致停止标志以true的形式执行 processWorkerExit() 方法。关于该方法的逻辑本篇暂时不做结束，后续再其他博客中展开。

通过该方法，我们可以看出线程池中，工作线程能够复用的主要原理是：通过单线程执行多个任务的 run() 方法。其中在处理完某个任务后，通过 getTask() 方法获取新的任务执行。

最后，我们来看一下 getTask() 方法的实现原理。

5、getTask()

在线程池中，工作线程循环调用 getTask() 方法获取任务进行执行，这也是线程池单线程执行多任务的原理。我们直接看源码：

private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }
        int wc = workerCountOf(c);
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }
        try {
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

其中该方法逻辑有点绕，我先通过流程图的方式给出大体逻辑，下面通过文字对比较绕的模块单独介绍：
获取任务方法
判断线程池是否停止：可以理解为线程池是否不工作了，主要表示以下两种场景：

线程池状态为STOP及以后
线程池状态为SHUTDOWN，并且阻塞队列已经为空

这里主要为了区分线程池处于SHUTDOWN，但是队列不为空的情况。我们知道，线程池处于SHUTDOWN状态时，还是会处理阻塞队列中的任务的，也就是还在工作的。

判断是否超时回收：当存在以下两种情况时，超时线程才会被回收：

配置 allowCoreThreadTimeOut 为 True，也就是所有线程空闲都会回收
线程数超过最大核心线程数，也就可以理解为非核心线程空闲都会被回收

判断线程是否可回收：判断一个线程是否可回收主要集中在以下两种情况，其中无论哪种情况至少得满足下述两种情况中的一种：

线程数大于1，也就是说有线程可回收
阻塞队列为空，也就是说当前没有任务需要执行

判断可回收的情况如下：

线程数大于最大线程数
线程已超时，并且该线程超时会被回收

流程图中比较模糊的几个判断及解释已经给出，现在我们再来看 getTask()方法。

我理解 getTask() 方法的核心作用是控制工作线程的周期。可以总结为：

如果当前线程是可回收的，超过最长空闲时返回null，线程执行 processWorkerExit() 方法被回收
如果线程是不可回收的，就阻塞线程，直到有任务时返回任务，交给工作线程处理

最后我们再来聊聊线程回收，通过总结上述代码，我认为只有三种情况才会回收线程：

线程池不工作了
超时可回收线程超时了
线程数超过最大线程，并且当前没有任务

**那么线程池是如何做到阻塞工作线程不让它被回收的呢？又是如何做到回收线程？

答：阻塞队列的 take() 方法在队列为空时会阻塞，因此线程也会阻塞，此时线程就会一直等待任务，不被回收。阻塞队列的 poll() 方法不会阻塞，如果线程池为空，直接返回null。回到 runWorker() 方法，如果任务为空，就会跳出循环执行 processWorkerExit() 方法，该方法会通过 tryTerminate() 方法停止线程并回收。