尽可能的说明白ThreadPoolExecutor的原理

线程池用来执行任务的,是通过创建线程来执行任务的,这个线程什么时候被创建呢,是在内部类Worker的构造函数中才会被创建。这个线程的作用就是不停的从阻塞队列中获取任务然后执行。

问:线程池是如何创建线程的?

答:在Worker类的构造函数里。

问:Worker什么时候会被构造?

答:是在方法addWorker()中。

问:线程池的线程启动之后用来做什么?

答:会调用runWorker()方法。

线程池的状态机

  • RUNNING:运行状态,接受新的任务,处理等待队列中的任务
  • SHUTDOWN:不接受新的任务提交,但是会继续处理等待队列中的任务
  • STOP:不接受新的任务提交,不再处理等待队列中的任务,中断正在执行任务的线程
  • TIDYING:所有的任务都销毁了,workCount 为 0。线程池的状态在转换为 TIDYING 状态时,会执行钩子方法 terminated()
  • TERMINATED:terminated() 方法结束后,线程池的状态就会变成这个

> RUNNING 定义为 -1,SHUTDOWN 定义为 0,其他的都比 0 大,所以等于 0 的时候不能提交任务,大于 0 的话,连正在执行的任务也需要中断。
>
> RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED

Worker

Worker是ThreadPoolExecutor的内部类,可以简单的理解为Worker就是工作线程,让我看看Worker的类结构:

private final class Worker extends AbstractQueuedSynchronizer implements Runnable
{
    // 这个是真正的线程,这个Worker对象在thread这个线程中运行的,也就是说这个thread就是运行在线程池中的线程
    final Thread thread;

    // Worker对象执行的第一个任务,如果为null,他会不停从任务队列(BlockingQueue)中取任务(getTask 方法)
    Runnable firstTask;

    // 用于存放此线程完全的任务数,注意了,这里用了 volatile,保证可见性
    volatile long completedTasks;
    // Worker 只有这一个构造方法,传入 firstTask,也可以传 null
    Worker(Runnable firstTask) {
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        // 调用 ThreadFactory 来创建一个新的线程,传入this
        this.thread = getThreadFactory().newThread(this);
    }
    // 这里调用了外部类的 runWorker 方法
    // 这thread线程中执行 run 方法
    public void run() {
        runWorker(this);
    }
    ...// 其他几个方法没什么好看的,就是用 AQS 操作,来获取这个线程的执行权,用了独占锁
}

Worker类的作用根据上面的属性说明应该能够理解了。Worker构造函数接收一个task属性,这个Worker启动之后会先执行这个task,然后再去阻塞队列中获取任务执行,如果获取不到任务了,这个Worker就会执行完了,这个线程也就结束了。

进入正题,ThreadPoolExecutor#execute(Runnable command)

我们看下ThreadPoolExecutor的最重要的方法execute(Runnable command),它是如何处理新任务:

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

    // 前面说的那个表示 “线程池状态” 和 “线程数” 的整数
    int c = ctl.get();

    // 如果当前线程数少于核心线程数,那么直接添加一个 worker 来执行新任务,
    if (workerCountOf(c) &lt; corePoolSize) {
        if (addWorker(command, true)) {
            // 表示添加成功了线程池已经接受了这个新任务,至于执行的结果,到时候会包装到 FutureTask 中
            return;
        }
        // 创建Worker失败,有可能是线程池状态被改变了,这里重新获取
        c = ctl.get();
    }
    // 执行到这里说明有两种情况:
    // 1、当前线程数大于等于核心线程数;
    // 2、刚刚 addWorker 失败了

    if (isRunning(c) &amp;&amp; workQueue.offer(command)) {
        // 正常情况下,只要队列未满,不会创建新线程
        // 如果线程池处于 RUNNING 状态,并且任务添加到阻塞队列成功(表示阻塞队列未满)

        int recheck = ctl.get();
        if (! isRunning(recheck) &amp;&amp; remove(command)) {
            // 重新检查下,如果线程池已不处于 RUNNING 状态,那么移除已经入队的这个任务,并且执行拒绝策略
            reject(command);
        }
        else if (workerCountOf(recheck) == 0) {
            // 如果线程池还是 RUNNING 的,并且线程数为 0,那么开启新的线程,怕线程池为空就没人处理任务了
            addWorker(null, false);
        }
    }
    // 如果 workQueue 队列满了,那么进入到这个分支
    // 以 maximumPoolSize 为界创建新的 worker,
    // 如果失败,说明当前线程数已经达到 maximumPoolSize,执行拒绝策略
    else {
        // 这里有两种情况:
        // 1、线程池状态不是RUNNING,不支持新任务,reject
        // 2、线程状态为RUNNING,但是阻塞队列满了(workQueue.offer(command)返回false表示满了),就用最大线程数为界限创建
        if (!addWorker(command, false)) {
            // 两种情况会拒绝:
            // 1、线程池状态不是RUNNING,拒绝新任务
            // 2、线程状态为RUNNING,但是超过最大线程数了,拒绝新任务
            reject(command);
        }

    }
}

> 从源码中我们可以看到:线程池在RUNNING状态时
>
> 1、线程数量小于核心线程数,就创建新线程处理新任务。代码中得到印证
> 2、线程数量大于等于核心线程数,就尝试把新任务放入阻塞队列。代码中得到印证
> 3、阻塞队列满了之后,线程数量小于最大线程数,就创建新线程处理任务。代码中得到印证

execute(Runnable command)方法中只调用了创建了Worker,那Worker对象究竟是怎么执行任务的呢,首先我们得先看下Worker是如何创建的,线程是何时运行的,我们先看下addWorker(Runnable firstTask, boolean core)这个方法是如何创建线程的

// 第一个参数表示交个这个线程的第一个执行的任务,可以为null,如果不是null,表示这是个新任务
// 第二个参数为 true 代表使用核心线程数 corePoolSize 作为创建线程的界线,也就说创建这个线程的时候,
// 如果线程池中的线程总数已经达到 corePoolSize,那么不能创建线程
// 如果是 false,代表使用最大线程数 maximumPoolSize 作为界线

// 在调用者所在的线程中,向线程池中创建线程
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c); // rs是当前线程池状态

        // 只有两种情况,才能往下走,否则直接不创建新的线程
        // 1、线程池状态为 RUNNING
        // 2、线程池状态为 SHUTDOWN ,并且不是新任务(firstTask == null表示不是新任务),并且阻塞队列不为空(表示队列里还有任务)
        // 结合线程池状态说明下:
        // 1、当线程池处于 SHUTDOWN 的时候,不允许提交任务,但是可以创建线程去处理队列中已有的任务
        // 多说一句:如果线程池处于 SHUTDOWN,但是 firstTask 为 null,且 workQueue 非空,那么是允许创建 worker 的
        if (rs &gt;= SHUTDOWN &amp;&amp;
                            ! (rs == SHUTDOWN &amp;&amp;
                                            firstTask == null &amp;&amp;
                                            ! workQueue.isEmpty()))
                return false;
        for (;;) {
            // 线程的数量超过界限就不能创建
            int wc = workerCountOf(c);
            if (wc &gt;= CAPACITY ||
                wc &gt;= (core ? corePoolSize : maximumPoolSize))
                return false;
            // CAS操作设置线程数量+1,如果成功,那么就是所有创建线程前的条件校验都满足了,准备创建线程执行任务了
            if (compareAndIncrementWorkerCount(c))
                break retry;
            // 由于有并发,重新再读取一下 ctl
            c = ctl.get();
            // 可是如果是因为其他线程的操作,导致线程池的状态发生了变更,如有其他线程关闭了这个线程池,那么需要回到外层的for循环
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
            // CAS操作失败的话,说明有其他线程也在尝试往线程池中创建线程,重新内部循环
        }
    }
    /* 
     * 到这里,我们认为在当前这个时刻,可以开始创建线程来执行任务了,
     */

    // worker 是否已经启动
    boolean workerStarted = false;
    // 是否已将这个 worker 添加到 workers 这个 HashSet 中
    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 c = ctl.get();
                int rs = runStateOf(c);
                // 小于 SHUTTDOWN 那就是 RUNNING,这个自不必说,是最正常的情况
                // 如果等于 SHUTDOWN,不接受新的任务(firstTask == null表示不是新任务),但是会继续执行等待队列中的任务
                if (rs &lt; SHUTDOWN ||
                    (rs == SHUTDOWN &amp;&amp; firstTask == null)) {
                    // worker 里面的 thread 可不能是已经启动的
                    if (t.isAlive())
                        throw new IllegalThreadStateException();
                    // 加到 workers 这个 HashSet 中
                    workers.add(w);
                    int s = workers.size();
                    // largestPoolSize 用于记录 workers 中的个数的最大值,
                    // 因为 workers 是不断增加减少的,通过这个值可以知道线程池的大小曾经达到的最大值
                    if (s &gt; largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            // 添加成功的话,启动这个线程
            if (workerAdded) {
                // 启动线程去执行worker
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        // 如果线程没有启动,需要做一些清理工作,如前面 workCount 加了 1,将其减掉
        if (! workerStarted)
            addWorkerFailed(w);
    }
    // 返回线程是否启动成功
    return workerStarted;
}

我们已经看到线程启动了,那这个线程启动做了什么事情呢,我们看下runWorker(Worker w)这个方法。

// Worker 类的 run() 方法
public void run() {
    runWorker(this);
}
// 此方法由 worker 线程启动后调用,这里用一个 while 循环来不断地从等待队列中获取任务并执行
// 前面说了,worker 在初始化的时候,可以指定 firstTask,那么第一个任务也就可以不需要从队列中获取
final void runWorker(Worker w) {
    // 
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        // 循环调用 getTask 获取任务
        while (task != null || (task = getTask()) != null) {
            w.lock();          
            // 如果线程池状态大于等于 STOP,那么意味着该线程也要中断
            // 不是STOP,就把线程从中断恢复Thread.interrupted()
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &amp;&amp;
                  runStateAtLeast(ctl.get(), STOP))) &amp;&amp;
                !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) {
                    // 这里不允许抛出 Throwable,所以转换为 Error
                    thrown = x; throw new Error(x);
                } finally {
                    // 也是一个钩子方法,将 task 和异常作为参数,留给需要的子类实现
                    afterExecute(task, thrown);
                }
            } finally {
                // 置空 task,准备 getTask 获取下一个任务
                task = null;
                // 累加完成的任务数
                w.completedTasks++;
                // 释放掉 worker 的独占锁
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {Exit 中处理
        // 限于篇幅,我不准备分析这个方法了,感兴趣的读者请自行分析源码
        processWorkerExit(w, completedAbruptly);
    }
}

让我们继续分析,Worker是如何从阻塞队列中获取任务的

// 方法返回null,线程数会减一,也表示Worker的线程就会执行结束而关闭了
private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?

    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.

        if (rs &gt;= SHUTDOWN &amp;&amp; (rs &gt;= STOP || workQueue.isEmpty())) {
            // 两种可能会减少线程,返回null
            // 1. 线程池状态为 SHUTDOWN ,而且阻塞队列为空,任务执行完了
            // 2. 线程池状态 &gt;= STOP,不管阻塞队列是否还有任务,直接返回null
            decrementWorkerCount();
            return null;
        }

        int wc = workerCountOf(c);

        // Are workers subject to culling?
        // timed=true,表示需要关闭空闲的线程
        // allowCoreThreadTimeOut表示是否允许核心线程数空闲时候关闭它
        boolean timed = allowCoreThreadTimeOut || wc &gt; corePoolSize;

        if ((wc &gt; maximumPoolSize || (timed &amp;&amp; timedOut))
                        &amp;&amp; (wc &gt; 1 || workQueue.isEmpty())) {
            // 这里有两种情况会减少线程,返回null:
            // 1、线程数大于最大线程数(比如手动设置,把最大线程数设置小了)
            // 2、线程数小于等于最大线程数,但是在keepAliveTime时间内没有获取到任务,表示空闲
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }

        try {
            Runnable r = timed ?
                            workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                            workQueue.take();
            if (r != null)
                return r;
            // r == null,只有workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)超时了才会返回
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

线程池提交任务的流程简述

写到这里,我才能正在理解下面这张图,这是在正常情况下,也就是RUNNING状态下,任务提交的流程。

![]()

线程关闭

shutdown,修改状态为SHUTDOWN,拒绝新任务,会继续执行阻塞队列中的任务,中断闲置的Worker。

shutdownNow,修改状态为STOP,拒绝新任务,中断所有Worker,会影响阻塞队列中的任务。

shutdown

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock(); // 关闭的时候需要加锁,防止并发
    try {
        checkShutdownAccess(); // 检查关闭线程池的权限
        advanceRunState(SHUTDOWN); // 把线程池状态更新到SHUTDOWN
        interruptIdleWorkers(); // 中断闲置的Worker
        onShutdown(); // 钩子方法,默认不处理。ScheduledThreadPoolExecutor会做一些处理
    } finally {
        mainLock.unlock(); // 解锁
    }
    tryTerminate(); // 尝试结束线程池,上面已经分析过了
}
// shutdownNow方法会有返回值的,返回的是一个任务列表,而shutdown方法没有返回值
public List&lt;Runnable&gt; shutdownNow() {
    List&lt;Runnable&gt; tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock(); // shutdownNow操作也需要加锁,防止并发
    try {
        checkShutdownAccess(); // 检查关闭线程池的权限
        advanceRunState(STOP); // 把线程池状态更新到STOP
        interruptWorkers(); // 中断Worker的运行
        tasks = drainQueue();
    } finally {
        mainLock.unlock(); // 解锁
    }
    tryTerminate(); // 尝试结束线程池,上面已经分析过了
    return tasks;
}

闲置Worker是这样解释的:Worker运行的时候会去阻塞队列拿数据(getTask方法),拿的时候如果没有设置超时时间,那么会一直阻塞等待阻塞队列进数据,这样的Worker就被称为闲置Worker。由于Worker也是一个AQS,在runWorker方法里会有一对lock和unlock操作,这对lock操作是为了确保Worker不是一个闲置Worker。

private void interruptIdleWorkers(boolean onlyOne) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock(); // 中断闲置Worker需要加锁,防止并发
    try {
        for (Worker w : workers) { 
            Thread t = w.thread; // 拿到worker中的线程
            if (!t.isInterrupted() &amp;&amp; w.tryLock()) { // Worker中的线程没有被打断并且Worker可以获取锁,这里Worker能获取锁说明Worker是个闲置Worker,在阻塞队列里拿数据一直被阻塞,没有数据进来。如果没有获取到Worker锁,说明Worker还在执行任务,不进行中断(shutdown方法不会中断正在执行的任务)
                try {
                    t.interrupt();  // 中断Worker线程,从阻塞队列的take()中中断
                } catch (SecurityException ignore) {
                } finally {
                    w.unlock(); // 释放Worker锁,放在lock阻塞
                }
            }
            if (onlyOne) // 如果只打断1个Worker的话,直接break退出,否则,遍历所有的Worker
                break;
        }
    } finally {
        mainLock.unlock(); // 解锁
    }
}

> shutdown方法里的worker.tryLock和runWorker里的worker.lock会有可能同时发生
>
> 1、lock先,tryLock就会false,线程不会被中断
>
> 2、tryLock=true,线程会中断,lock会阻塞,等待恢复(tryLock之后会unlock),恢复之后,将线程从中断状态恢复
>
> 来源:35分类目录

声明:该文章系转载,转载该文章的目的在于更广泛的传递信息,并不代表本网站赞同其观点,文章内容仅供参考。

本站是一个个人学习和交流平台,网站上部分文章为网站管理员和网友从相关媒体转载而来,并不用于任何商业目的,内容为作者个人观点, 并不代表本网站赞同其观点和对其真实性负责。

我们已经尽可能的对作者和来源进行了通告,但是可能由于能力有限或疏忽,导致作者和来源有误,亦可能您并不期望您的作品在我们的网站上发布。我们为这些问题向您致歉,如果您在我站上发现此类问题,请及时联系我们,我们将根据您的要求,立即更正或者删除有关内容。本站拥有对此声明的最终解释权。