Java 线程池 ThreadPoolExecutor 源码逐行浅析

最新推荐文章于 2024-05-29 15:09:45 发布

chennaoxi9356

最新推荐文章于 2024-05-29 15:09:45 发布

阅读量222

点赞数

文章标签： java

原文链接：https://my.oschina.net/u/852678/blog/919775

版权

关于线程池的文章很多，有的充斥着理论和各种专业名词，很容易让人犯晕、搞混概念，降低理解线程池的效率。有的写得很详细很好，但忽略了一些地方。于是我索性抛开这些文章，直接深入源码，重新抽丝剥茧，不过难免犯错走进代码逻辑的死胡同，再翻看别人的好文章才得以走通。现在把总结写出来，尽量用源码（jdk 1.8）说话，用简单的语言说通概念和逻辑，作为别人文章的一种补充。如有错误或不足，欢迎指出。

线程池的好处

线程池其中一个好处是什么？

线程复用，减少系统开销。

众所周知，创建一个线程系统开销大。假设有以下代表任务的类

class MyTask implements Runnable{
    public void run(){
        //...
    };
}

如果要创建10个该任务并行执行，就要创建10个线程。

for(int i=0;i<10;i++){
    Thread t = new Thread(new MyTask());
    t.start();
}

如果用了线程池，只需这样。假设使用具有固定线程的线程池，且只有5个线程，执行10个任务，比上例系统开销少一半，平均一个线程执行2个任务，这就是线程复用。

ExecutorService es = Executors.newFixedThreadPool(5);
for(int i=0;i<10;i++){
    es.execute(new MyTask());
}
es.shutdown();

线程池的种类和概念

线程池的种类

通过java.util.concurrent.Executors创建不同类型的线程池：

Executors.newCachedThreadPool()

创建无界线程池，动态地根据任务数和处理能力新增或回收线程。任务统统被放在阻塞队列里排队，每个线程都尝试从阻塞队列里取出任务，有任务就执行它。当队列没有任务时，线程阻塞60秒，60秒后依然没有任务，回收线程。当每个线程都繁忙，队列还有任务在等待，就再创建一个线程执行它。

Executors.newFixedThreadPool( int n)

创建有界的线程池，线程池里只有n个线程，线程处理完一个任务就从阻塞队列里取出其他任务。当所有线程都在忙，其他任务在队列里等待。

Executors.newSingleThreadExecutor()

创建单线程的线程池。

Executors.newScheduledThreadPool( int n)

（因为这个线程池是另一个线程池类，所以不在本文讨论之列，详细可看其他文章。）

从Executors源码可以看到，前三个方法创建的都是一样的线程池类ThreadPoolExecutor，只是参数不一样，本文只说这个类。

看ThreadPoolExecutor的构造方法和其属性，稍后逐个说明：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {

    //...（省略部分参数检查源码）
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue; 
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory; 
    this.handler = handler; 
}

ThreadPoolExecutor的内部类Worker

private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
    //...
}

首先Worker实现了Runnable接口。线程池中创建的线程，都是Worker线程，每个Worker线程通过直接调用任务实例的run方法，以实现对任务的执行。

另外Worker还继承了AbstractQueuedSynchronizer（后面简称AQS），使得Worker获得锁功能。为什么要锁功能？稍后再说，预告一下，就是shutdown方法和shutdownNow方法实现原理的区别。

PS：ReentranLock之所以能实现代码块的并发访问控制，就是因为继承了AQS而实现的（忘了是从JDK哪个版本开始，ReentranLock类抛开对其的依赖，而是通过内部类ReentrantLock.Sync来继承），而不是通过关键字synchronized等方式实现，可见其强大之处。以后有机会，我会去研究一下AQS，有结果就再写一篇文章。

ThreadPoolExecutor的重要属性

corePoolSize

直译为核心线程池大小，使用FixedThreadPool时才用到，用于限制创建Worker线程的数量。例如Executors.newFixedThreadPool(5)，corePoolSize就是5，只能创建5个Worker线程。

maximumPoolSize

直译为最大线程池大小，使用CachedThreadPool时才用到，默认值为Integer.MAX_VALUE，也用于限制创建Worker线程的数量，当然MAX_VALUE个线程只是极端情况，毕竟CachedThreadPool是按需创建或销毁线程。当使用FixedThreadPool时，此值等于corePoolSize。

keepAliveTime

Worker线程等待任务的时间，使用CachedThreadPool时此值默认为60秒，表示当阻塞队列没有任务时，线程等待60秒再取任务，还是没有的话，Worker线程被回收。FixedThreadPool该值为0

workQueue

它是一个无界LinkedBlockingQueue阻塞队列，任务在此排队等待被Worker获取和执行。队列为空时，Worker线程对队列的take/poll操作会阻塞进入等待状态。（我觉得命名为taskQueue会不会更好一点，毕竟它放的是任务。）

allowCoreThreadTimeOut

决定Worker线程如何从workQueue取出任务的行为。默认为false，当workQueue没有任务，Worker线程阻塞等待，直到该队列有任务为止。设为true，当workQueue没有任务，Worker线程只阻塞keepAliveTime时间，还是没有任务就返回null。

RejectExecutionHandler

拒绝策略，默认为AbortPolicy

ThreadFactory

创建Worker线程的线程工厂类，默认为Executors.DefaultThreadFactory

workers

Worker实例的集合，是个普通的HashSet。每次对workers的增删操作，有ReentranLock保证并发安全。

ctl

这个参数设计很巧妙，既用于记录Worker的数量，也用于记录线程池状态（生命周期）。

ctl属性

这个属性十分重要，看源码：

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
private static final int RUNNING    = -1 << COUNT_BITS;
private static final int SHUTDOWN   =  0 << COUNT_BITS;
private static final int STOP       =  1 << COUNT_BITS;
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;

其中静态参数RUNNING、SHUTDOWN、STOP、TIDYING和TERMINATED表示线程池的各种状态，由类型为AtomInteger的ctl记录当前线程池状态，保证对线程池状态的修改都是原子操作。ctl这个属性设计十分巧妙，我觉得是属于大牛级别的技术，可以借鉴应用到其他项目中，下面开始解释。

ctl有两个作用：

记录线程池状态
记录Worker数量，包括活动的和空闲的（或叫阻塞）。

线程池状态有：

RUNNING 线程池可用，可以通过execute方法添加新任务
SHUTDOWN 线程池已关闭，无法通过execute方法添加新任务，但已经排队的任务或正在执行的任务不受影响
STOP 线程池已停止，既无法通过execute方法添加新任务，在排队或正在执行的任务也要立即中断
TIDYING 线程池已经没有任务存在了，Worker数量也为0，可以终结线程池
TERMIATED 线程池已终结

奇怪，一个Integer，取值范围是-2^31 到 2^31-1，仅且只能有一个数值，如何既记录线程池状态，又记录Worker数量呢？二进制的厉害之处就在这里了，看下表列出了各状态的值：

属性	十进制	二进制	十六进制
CAPACITY	536870911	0001 1111 1111 1111 1111 1111 1111 1111	0x1FFFFFFF
RUNNING	-536870912	1110 0000 0000 0000 0000 0000 0000 0000	0xE0000000
SHUTDOWN	0	0000 0000 0000 0000 0000 0000 0000 0000	0x00000000
STOP	536870912	0010 0000 0000 0000 0000 0000 0000 0000	0x20000000
TIDYING	1073741824	0100 0000 0000 0000 0000 0000 0000 0000	0x40000000
TERMINATED	1610612736	0110 0000 0000 0000 0000 0000 0000 0000	0x60000000

线程池利用ctl的二进制数据的前3位记录状态，后29位记录Worker数量。

例如在RUNNING状态，有1个Worker时，ctl就是：

1110 0000 0000 0000 0000 0000 0000 0001，十进制即 -536870911。前3位111是RUNNING，后29位就是1的二进制。

RUNNING状态，有2个Worker时，ctl就是：

1110 0000 0000 0000 0000 0000 0000 0010，十进制即 -536870910，后29位是2的二进制

RUNNING状态，Worker最多时，ctl就是：

1111 1111 1111 1111 1111 1111 1111 1111，十进制即 -1，后29位是536870911的二进制

要如何从ctl中取得状态值和Worker数呢，通过“按位与”操作即可，看源码：

private static int runStateOf(int ctl){    //根据ctl的值取得状态
    return ctl & ~CAPACITY; 
}
private static int workerCountOf(int ctl){ //根据ctl的值取得Worker数
    return ctl & CAPACITY; 
}

又如何在ctl中设置状态值和Worker数呢？通过“按位或”操作即可，看源码：

private static int ctlOf(int rs, int wc) {    // rs是状态，wc是Worker数
    return rs | wc;
}

所以，ctl的初始值表示线程池状态是RUNNING，Worker数为0。

关于“按位或”在现实中的应用，可以参考这篇别人的文章《按位或在多选中的应用》

线程池状态的变化看下图，可以看到是单向的，参照上面的表格，线程池状态值只能变大：

线程池状态的变化

线程池工作流程及原理

之前已经提到，不管是Executors.newFixedThreadPool、Executors.newCacherThreadPool还是Executors.newSingleThreadExecutor，创建的对象都是ThreadPoolExecutor，只是构造方法的参数不同。现在以FixedThreadPool为例，分析其源码。

假设该线程池只有2个线程，放入3个任务（假设这3个任务都比较耗时），然后shutdown线程池：

ExecutorService es = Executors.newFixedThreadPool(2);
es.execute(new MyTask("Task_1"));
es.execute(new MyTask("Task_2"));
es.execute(new MyTask("Task_3"));
es.shutdown();

该线程池工作基本流程：

1. 创建线程数为2的有界线程池，初始状态为RUNNING。

2. 线程池处于RUNNING状态时，可以通过execute方法往线程池添加任务。

3. 假设每个任务都比较耗时，前2个任务分别给2个Worker线程执行，其余任务在workQueue里排队。

4. 关闭线程池，无法再通过execute方法添加新任务

a) 假设调用shutdown方法关闭线程池，虽然不能添加新任务，但正在执行的任务和排队的任务不受影响，此时线程池状态为SHUTDOWN。

b) 假设调用shutdownNow方法关闭线程池，不但无法添加新任务，而且正在执行的任务和排队的任务都被终止，此时线程池状态为STOP。

5. 当一个Worker线程完成一个任务，就立即从workQueue里取出其他任务。当workQueue已经没有任务，此Worker线程处于空闲状态（阻塞），直到workQueue再有任务时才继续执行。

6. 当线程池处于SHUTDOWN状态时，workQueue没有任务，其中一个刚执行完最后一个任务的Worker线程先调用tryTerminate()尝试终结其他空闲的Worker线程，再终结自己。

7. 当所有Worker线程已经终结，线程池状态设为TIDYING，线程池跟着终结，状态最后变为TERMINATED。

execute方法流程图

这个流程图忽略了部分不那么重要的细节，只展示重要的工作流程和逻辑。稍后的源码分析也分开Main线程和Worker线程来分析，我觉得这样比较好理解多线程下的流程。

使用FixedThreadPool时execute方法的流程图

Main线程，execute方法

线程池就通过这个方法添加任务Task

public void execute(Runnable task){
    int c = ctl.get();
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(task, true))
            return;
        c = ctl.get();
    }
    if (isRunning(c) && workQueue.offer(task)){
	    //...
    }
}

exeucute方法很简单，先通过ctl取得Worker数（包括繁忙和空闲的），小于corePoolSize就调用addWorker方法创建Worker实例和Worker线程，执行传入的任务Task。大于corePoolSize就将任务Task放入workQueue排队。如果线程池状态不是RUNNING了，就拒绝任务Task。

Main线程，addWorker方法

addWorker用于创建Worker实例，并负责启动Worker线程。分两部分，前一部分通过两个for循环来检测是否足够条件执行addWorker。

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

        //  当初我就在这里犯了低级错误，搞错了逻辑，导致之后对流程的理解进入了死循环。当满足这些条件时，返回fasle，拒绝加入任务Task，条件有：
        //  1.	状态为STOP、DIDYING或TERMINATE
        //  2.	SHUTDOWN时firstTask为null
        //  3.	SHUTDOWN时workQueue为空
        if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null &&! workQueue.isEmpty()))
            return false;

        for (;;) {
        
            //  这里只判断Worker数是否超过线程池容许的线程数量，超过肯定拒绝加入任务
            int wc = workerCountOf(c);
            if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize))
                return false;

            //  如果以上拒绝条件都没有，就给ctl的Worker数量+1，并跳出循环，进入addWorker的下一部分
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();
            if (runStateOf(c) != rs)
                continue retry;
        }
    }
    //...
}

addWorker方法的第二部分，忽略了try代码和判断代码

Worker w = new Worker(firstTask);
final Thread t = w.thread;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)){
    workers.add(w);		//workers只是个HashSet，由mainLock保证并发安全
}
mainLock.unlock();
t.start();				//启动Worker线程

创建Worker实例，Worker类继承了AQS实现了Runnable接口，其构造方法也很简单

private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
    Worker(Runnable firstTask) {
        setState(-1);                //设置AQS的state状态，0表示未锁定，1表示锁定
        this.firstTask = firstTask;                        //Worker维护了任务Task
        this.thread = getThreadFactory().newThread(this);  //创建Worker线程
    }
    //...
}

初始化Worker时为什么state为-1而不是0，后面会解释。

addWorker方法成功，返回true，并结束execute方法。

当Main线程执行完三次execute方法添加了三个任务Task后（假设每个任务都比较耗时），线程池状态如下。此时还有2个Worker线程，正在执行任务Task_1和Task_2，Task_3在排队。

3个execute方法执行完的线程池状态

Main线程，shutdown方法

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(SHUTDOWN);  //设置ctl的状态为SHUTDOWN
        interruptIdleWorkers();     //中断空闲的Worker线程，稍后再详细分析
        onShutdown();               //触发shutdown事件，默认啥都没做
    } finally {
        mainLock.unlock();
    }
    tryTerminate();                 //尝试终结线程池
}

由于目前仍有Worker线程在执行任务，在此条件下shutdown方法也仅仅是将线程池状态设为SHUTDOWN，其他行为稍后分析。

此时，Main线程的步骤已经走完，开始看另外两个Worker线程到底在干嘛。

Worker线程，runWorker方法

先看看runWorker的简单流程图，依然忽略了一些不重要的细节

Worker线程的runWorker方法流程图

众所周知，当Worker线程调用start方法启动线程，实则调用Worker实例的run方法，看源码，它直接调用ThreadPoolExecutor的runWorker方法

public void run() {
    runWorker(this);		//this是Worker实例
}

省略了部分无关紧要的runWorker代码

final void runWorker(Worker w){
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock();                 // a)
    boolean completedAbruptly = true;

    //从Worker里取出任务Task，如果为null就通过getTask方法从workQueue里取，都是null就结束，让当前Worker进入销毁阶段
    while (task != null || (task = getTask()) != null){
        w.lock();              // b)

        //当线程池处于STOP状态，线程中断自己
        if ((runStateAtLeast(ctl.get(), STOP) ||
                (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
            wt.interrupt();

        task.run();           //直接调用任务Task的run方法，执行任务本身
        task = null;          //重置task引用，目的是执行完一个任务，再执行workQueue里的另一个任务
        w.unlock();           // c)
        completedAbruptly = false;
    }
    //当连getTask也返回null表示没有任何任务，可以销毁当前Worker实例
    processWorkerExit(w, completedAbruptly);
}

上面的代码注释不难理解，然而a)、b)和c)步骤是什么鬼呢？有什么用呢？这涉及到Worker线程的中断机制：

a) 通过unlock方法给Worker实例解锁（AQS的state设为1），此时Worker线程还没开始访问任务Task，表示Worker线程可以被其他线程中断

b) 在while代码块里，表示任务Task已经准备就绪，通过lock方法给Worker实例加锁，表示Worker线程开始执行任务，不能被其他Worker线程中断，只能在线程池处于STOP状态时自己中断自己（回顾之前STOP的描述），或被Main线程强制中断。

c) 任务Task已经顺利完成，解锁Worker实例（AQS的state设为0）。

也就是说，当Worker线程在执行任务时，Worker处于lock状态。当完成任务或任务没有就绪，Worker处于unlock状态。

为什么其他Worker线程要取得别的Worker的锁时才能中断它的线程。Main线程则不要取得锁就可以中断别的Worker线程，个中实现原理在后面介绍interruptIdleWorkers方法中会说到。

Worker线程，getTask方法

假设此时任务Task_2已经完成，Woker#2实例就访问workQueue，发现有任务Task_3，就取出并执行。

Worker线程的getTask方法的线程池状态

如何从workQueue取出任务Task_3的呢，看getTask方法源码。

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

        //  当满足这些条件时，终止getTask方法，返回null，并将ctl的Worker数量减一。表示当前Worker已经没有任务可以执行，进入销毁步骤
        //  1.	线程池是STOP、TIDYING或TERMINATE时
        //  2.	SHUTDOWN时，workQueue为空
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }
        int wc = workerCountOf(c);
		
        //使用FixedThreadPool且allowCoreThreadPool为fasle，此为false
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
		
        //如果Worker数超过线程池极限，当然不能再增加活动的Worker。或者poll超时，当前Worker自然也要终结，返回null进入销毁步骤
        if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
                continue;
        }

        //从阻塞队列取出任务Task，如果allowCoreThreadPool为true就用poll方法，否则take方法
        Runnable r = timed ? 
                       workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                       workQueue.take();
       if (r != null)
           return r;
       timedOut = true;		//记录poll超时
    }
}

阻塞队列的poll方法和take方法有什么区别呢？

poll方法从阻塞队列中取出对象，如果队列为空，则当前线程阻塞keepAliveTime时间再尝试取出，还是没有就返回null，记录超时状态，在重新进入for循环时才试图终结Worker。
take方法是，如果队列为空，当前线程则一直阻塞，直到队列有对象为止，返回该对象。

所以当使用FixedThreadPool，都是take方法，Worker线程有可能在这里出现阻塞。使用CachedThreadPool且allowCoreThreadTimeOut为true，则是poll方法。

现在假设这么一个情况，Worker#2线程在getTask方法第一段代码workQueue.isEmpty()时，Task_3还是在的。但中途线程调度器切换到Worker#1线程，并处理完之前的任务，并workQueue.take()取出了Task_3任务执行。线程调度器切换回Worker#2线程，当来到workQueue.take()时，阻塞队列已经没有对象，Worker#2线程阻塞，进入空闲状态。

Worker线程getTask方法可能的线程池状态

Worker#1线程，runWorker方法

现在Worker#2线程处于阻塞状态，只剩Worker#1线程在运行了。

while (task != null || (task = getTask()) != null){
    w.lock();	
    task.run();			//执行任务Task_3
    task = null; 
    w.unlock();
}
processWorkerExit(w, completedAbruptly);

当执行完任务Task_3之后，再次调用getTask方法，workQueue为空，返回null，结束while循环，调用processWorkerExit方法，Worker#1开始销毁步骤。

要清楚一点，此时Worker#2实例是没有锁的，没有锁的，没有锁的。因为lock方法在getTask方法之后，而Worker#2在getTask方法中处于阻塞状态，所以Worker#2实例是处于unlock状态，这十分重要，后面会解释。

Worker#1线程，processWorkerExit方法

当Worker没有任务可以处理，进入自销毁阶段。

省略了部分不重要的代码段

private void processWorkerExit(Worker w, boolean completedAbruptly){
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        completedTaskCount += w.completedTasks;    //线程池总的执行任务数
        workers.remove(w);                         //从workers删除一个Worker实例
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
	
    //...
    addWorker(null, false);
}

最后的addWorker(null)是什么意思呢，就是在RUNNING或SHUTDOWN且workQueue非空时，再创建一个Worker处理workQueue里余下的任务。通常CacherThreadPool才有这一步，意味着所有Worker都繁忙，刚好在processWorkerExit方法执行中又有新任务加入，线程池动态新创建一个Worker进行处理。

如果是FixedThreadPool，addWorker(null)返回false，不做任何事。

Worker#1线程，tryTerminate方法

尝试终结线程池，将状态设为TIDYING，最后设为TERMINATED

简单流程图如下

tryTerminate方法流程图

终止tryTerminate方法的条件有：

线程池状态是RUNNING时
线程池状态是SHUTDOWN时workerQueue非空
线程池状态已经是TIDYING或TERMINATE时
ctl的Worker数不为0

ctl的Worker数不是0，意味着还有Worker线程在执行任务，或有Worker线程空闲（阻塞），就调用interruptIdleWorkers(ONLY_ONE)中断一个空闲（阻塞）的Worker线程，并结束。

int c = ctl.get();
if (isRunning(c) || runStateAtLeast(c, TIDYING) || 
        (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
    return;
if (workerCountOf(c) != 0) {
    interruptIdleWorkers(ONLY_ONE);		// 中断一个空闲（阻塞）的Worker线程
    return;
}

worker数为0，表示已经没有任何任务，也没有任何Worker，可以将线程池状态设为TIDYING，然后再设为TERMINATED。

if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
    try {
        terminated();						//空方法
    } finally {
        ctl.set(ctlOf(TERMINATED, 0));
        termination.signalAll();			//唤醒其他线程
    }
    return;
}

Worker#1线程，interruptIdleWorkers方法

负责中断一个空闲的Worker线程。分析这个方法之前，先看看shutdown方法和shutdownNow方法有什么不一样。

shutdown方法的代码片段：

checkShutdownAccess();
advanceRunState(SHUTDOWN);
interruptIdleWorkers();    //看这里
onShutdown();

shutdownNow方法的代码片段：

List<Runnable> tasks;
checkShutdownAccess();
advanceRunState(STOP);
interruptWorkers();    //看这里
tasks = drainQueue();

区别就是：

shutdown方法调用interruptIdleWorkers方法
shutdownNow方法调用interruptWorkers方法

再看看interruptIdleWorkers方法和interruptWorkers方法有什么不一样

interruptIdleWorkers方法的代码片段：

for (Worker w : workers) {
    Thread t = w.thread;
    if (!t.isInterrupted() && w.tryLock()) {		//尝试取得Worker的锁
        try {
            t.interrupt();
        } catch (SecurityException ignore) {
        } finally {
            w.unlock();
        }
    }
    if (onlyOne)
        break;
}

interruptWorkers方法的代码片段：

for (Worker w : workers)
    w.interruptIfStarted();

可以看到，interruptIdleWorkers方法在尝试中断其他线程时，会先对Worker#2调用tryLock方法尝试取得Worker#2的锁。我还没有研究AQS的源码，但我已经猜测到，当Worker#1线程尝试取得Worker#2的锁时，如果无法取得（代表Worker#2正在执行任务），则Worker#1线程在此阻塞。如果取得，Worker#1线程就中断Worker#2线程，那么Worker#2线程抛出InterruptedException。

interruptWorkers方法就不一样，它不会尝试取得Worker锁，它不管Worker是否有锁，立即中断该线程。看interruptIfStarted方法的源码：

Thread t;
//AQS的state为0表示未锁定，1表示锁定。Worker实例初始化时state为-1，表示我还没开始工作做贡献实现价值呢，你不要中断我的。
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) 
    t.interrupt();

纵观ThreadPoolExecutor所有代码，只有shutdownNow方法调用interruptWorkers方法。

所以，这就是Worker加锁时（正在执行任务）不能被其他Worker线程中断的原理。而当Main线程强制调用shutdownNow方法时，Worker无论是否有锁，也能被Main线程中断。

至此，Worker#1线程的interruptIdleWorkers方法中断了Worker#2线程，Worker#2线程抛出InterruptedException，（回顾getTask方法的代码）。

Worker#1线程也已完结

完结

最后贴出Executors.newCachedThreadPool()的基本流程，依然省略了不那么重要的步骤。

使用CachedThreadPool时execute方法的流程图

如果想了解详细的流程，可以参考别人的文章：

《ThreadPoolExecutor核心实现原理和源码解析<一>》

《ThreadPoolExecutor核心实现原理和源码解析<二>》

转载于:https://my.oschina.net/u/852678/blog/919775

chennaoxi9356

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 线程池 ThreadPoolExecutor 源码逐行浅析

关于线程池的文章很多，有的充斥着理论和各种专业名词，很容易让人犯晕、搞混概念，降低理解线程池的效率。有的写得很详细很好，但忽略了一些地方。于是我索性抛开这些文章，直接深入源码，重新抽丝剥茧，不过难免犯错走进代码逻辑的死胡同，再翻看别人的好文章才得以走通。现在把总结写出来，尽量用源码（jdk 1...
复制链接

扫一扫