JAVA线程池的实现原理、ThreadPoolExecutor源码分析

╰+哭是因爲堅強的太久メ 2022-05-26 12:43 263阅读 0赞

# 关于Executors工具类 #

通过Executors工具类，我们可以快速的创建线程池

//创建具有自动调整功能的线程池
    ExecutorService executorService1 = Executors.newCachedThreadPool();
    //创建单条线程的线程池
    ExecutorService executorService2 = Executors.newSingleThreadExecutor();
    //创建固定大小的线程池
    ExecutorService executorService3 = Executors.newFixedThreadPool(10);

我们点击`newSingleThreadExecutor`方法的源码查看

public static ExecutorService newSingleThreadExecutor() { 
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

可以看到其实是调用的`ThreadPoolExecutor`类的构造方法，`newCachedThreadPool`和`newFixedThreadPool`也是一样，  
总结：上面几个办法，归根结底调用的其实是`ThreadPoolExecutor`类的构造方法，下面我们详细来看`ThreadPoolExecutor`类的源码。

# 关于ThreadPoolExecutor类 #

`ThreadPoolExecutor`类中定义了一些属性，这些属性用于标识线程池目前的状态。

// AtomicInteger是原子类 ctlOf()返回值为RUNNING；
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    // 高3位表示线程状态
    private static final int COUNT_BITS = Integer.SIZE - 3;
    // 低29位表示workerCount容量
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
    
    // runState is stored in the high-order bits
    // 能接收任务且能处理阻塞队列中的任务
    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;
    
    // 存放任务的阻塞队列
    private final BlockingQueue<Runnable> workQueue;

线程池的状态转换如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMzI5MzM0MzI_size_16_color_FFFFFF_t_70]  
ThreadPoolExecutor的构造方法如下，通过这个方法可以很容易的创建一个线程池

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

各参数意义如下

1.  corePoolSize：线程池核心线程数量
2.  maximumPoolSize:线程池最大线程数量
3.  keepAliverTime：当活跃线程数大于核心线程数时，空闲的多余线程最大存活时间
4.  unit：存活时间的单位
5.  workQueue：存放任务的队列，一般使用LinkedBlockingQueue，需要指定大小，如果没有指定大小默认为Integer.Max
6.  handler：超出线程范围和队列容量的任务的处理程序

上面讲完了如何创建线程池，那么如何使用呢？

executorService1.execute(new Runnable() { 
    
    	@Override
    	public void run() { 
    	    System.out.println("hello thread");
    	}
    });

使用线程池的时候最终是调用了`ThreadPoolExecutor`类的`execute`方法执行我们创建的线程

public void execute(Runnable command) { 
        if (command == null)
            throw new NullPointerException();
        // clt记录着runState和workerCount
        int c = ctl.get();
        // 情况1. workerCountOf方法取出低29位的值，表示当前活动的线程数
        // 然后拿线程数和核心线程数做比较
        if (workerCountOf(c) < corePoolSize) { 
        	// 如果活动线程数<核心线程数
        	// addWorker添加工作线程方法,第二个参数表示限制添加线程的数量是根据corePoolSize来判断还是maximumPoolSize来判断
            if (addWorker(command, true))
                return;
            // 如果失败则重新获取 runState和 workerCount
            c = ctl.get();
        }
        // 情况2.走到这里说明核心线程数已经创建满了，则判断如果线程池是运行状态就把任务添加到队列中，如果添加成功的话就继续，否则走到情况3
        if (isRunning(c) && workQueue.offer(command)) { 
        	// 重新获取 runState和 workerCount
            int recheck = ctl.get();
            // 走到这里说明添加任务到队列中成功了，但是有可能刚添加成功线程池就被关闭了，所以再进行一次线程池是否是运行中的判断
            if (! isRunning(recheck) && remove(command))
            	// 走到这里说明线程池停止了，那就需要把当前任务从队列中移除，并且走拒绝策略
            	// 调用handler超出线程范围和队列容量的任务的处理程序
                reject(command);
            else if (workerCountOf(recheck) == 0)
            //进行线程池中的线程数判断，如果为0的话就再创建一个线程，第一个参数为null，表示在线程池中创建一个线程，但不去启动。第二个参数为false，将线程池的有限线程数量的上限设置为maximumPoolSize
                addWorker(null, false);
        }
        // 情况3. 走到这里说明核心线程已满且队列已满，再次调用addWorker方法，但第二个参数传入为false，将线程池的有限线程数量的上限设置为maximumPoolSize
        else if (!addWorker(command, false))
        	// 调用handler超出线程范围和队列容量的任务的处理程序
            reject(command);
    }

总结一下上诉代码做了什么事：

1.  当workerCount < corePoolSize，创建线程执行任务。
2.  当workerCount ≥ corePoolSize并且阻塞队列workQueue未满，把新的任务放入阻塞队列。
3.  当workerCount ≥ corePoolSize并且阻塞队列workQueue已满，并且workerCount < maximumPoolSize，创建普通线程执行任务。
4.  当workQueue已满，workerCount ≥ maximumPoolSize，采取拒绝策略,默认拒绝策略是直接抛异常。

流程图表示如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMzI5MzM0MzI_size_16_color_FFFFFF_t_70 1]  
可以看到使用线程池的时候会有三种情况

1.  核心线程未达到corePoolSize设定的值
2.  核心线程已达到corePoolSize设定的值但任务队列未满
3.  核心线程已满且队列已满

我们先说第一种情况

**情况1，核心线程未达到corePoolSize设定的值：**  
可以看到当核心线程未满时，会调用`addWorker()`方法来添加核心线程

// firstTask 指定新增线程执行的第一个任务或者不执行任务
    // core core如果为true则使用corePoolSize绑定，否则为maximumPoolSize。
    // 返回值是boolean类型，true表示新任务被接收了，并且执行了。否则是false
    private boolean addWorker(Runnable firstTask, boolean core) { 
    	retry:
        for (;;) { 
            int c = ctl.get();
            // 获取运行状态
            int rs = runStateOf(c);
    
            // 1. 线程池不在RUNNING状态并且状态是STOP、TIDYING或TERMINATED中的任意一种状态
            // 2. 线程池不在RUNNING状态，线程池接受了新的任务 
            // 3. 线程池不在RUNNING状态，阻塞队列为空。 
            // 满足这3个条件中的任意一个的话，拒绝执行任务
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;
    
            for (;;) { 
            	// 获取线程数wc
                int wc = workerCountOf(c);
                // 如果线程池线程数量超过线程池最大容量或者线程数量超过了基本大小(core参数为true，core参数为false的话判断超过最大大小)
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    // 超过返回false
                    return false;
                // 没有超过各种大小的话，cas操作线程池线程数量+1，cas成功的话跳出循环
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                // 重新检查状态
                c = ctl.get();
                // 如果状态改变了，重新循环操作
                if (runStateOf(c) != rs)
                    continue retry;
            }
        }
    	// 走到这一步说明cas操作成功了，线程池线程数量+1
        boolean workerStarted = false;	// 任务是否成功启动标识
        boolean workerAdded = false;	// 任务是否添加成功标识
        Worker w = null;
        try { 
        	// 把执行任务包装成一个Worker对象，这里的Worker对象实际上也是一个线程
            w = new Worker(firstTask);
            // 用Worker的属性thread，这个thread是使用ThreadFactory构造出来的
            final Thread t = w.thread;
            // ThreadFactory构造出的Thread有可能是null，做个判断
            if (t != null) { 
            	// 得到线程池的可重入锁
                final ReentrantLock mainLock = this.mainLock;
                // 加锁，防止并发
                mainLock.lock();
                try { 
                	// 在锁住之后再重新检测一下状态
                    int rs = runStateOf(ctl.get());
                    // 如果线程池在RUNNING状态（<SHUTDOWN标识处于Running状态）或者线程池在SHUTDOWN状态并且任务是个null
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) { 
                        // 判断线程是否还活着，也就是说线程已经启动并且还没死掉
                        if (t.isAlive())
                        	// 如果存在已经启动并且还没死的线程，抛出异常
                            throw new IllegalThreadStateException();
                        //把前面的Worker对象添加的workers中，是个HashSet
                        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 { 
        	// 如果任务启动失败，调用addWorkerFailed方法
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

Worker类也是一个线程对象

private final class Worker
            extends AbstractQueuedSynchronizer
            implements Runnable
        { 
    	    public void run() { 
                runWorker(this);
            }
        }

可以看到`Worker`类也是实现了`Runnable`接口，上面的`t.start()`调用的实际上是启动了`Worker`线程，也就是调用了`Worker`类本身的`run()`方法，`run()`调用了`runWorker()`方法

final void runWorker(Worker w) { 
    	// 得到当前线程
        Thread wt = Thread.currentThread();
        // 得到Worker中的任务task，也就是用户传入的task
        Runnable task = w.firstTask;
        // 将Worker中的任务置空
        w.firstTask = null;
        w.unlock();
        boolean completedAbruptly = true;
        try { 
        	// 如果用户传入的task不为空或者循环从workQueue中取出任务不为空
        	// getTask()方法在workQueue中没有任务的时候会堵塞，直到有任务加入或超时结束退出。
            while (task != null || (task = getTask()) != null) { 
            	// 如果拿到了任务，给自己上锁，表示当前Worker已经要开始执行任务了，已经不是闲置Worker
                w.lock();
                // 在执行任务之前先做一些处理。 
                // 1. 如果线程池已经处于STOP状态并且当前线程没有被中断，中断线程 
                // 2. 如果线程池还处于RUNNING或SHUTDOWN状态，并且当前线程已经被中断了，重新检查一下线程池状态，如果处于STOP状态并且没有被中断，那么中断线程
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try { 
                	// 任务执行前需要做什么，ThreadPoolExecutor是个空实现，用于用户自定义扩展
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try { 
                    	// 真正的开始执行任务，调用的是run方法，而不是start方法。这里run的时候可能会被中断，比如线程池调用了shutdownNow方法
                        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 { 
                    	// 任务执行结束需要做什么，ThreadPoolExecutor是个空实现，用于用户自定义扩展
                        afterExecute(task, thrown);
                    }
                } finally { 
                    task = null;
                    // 记录执行任务的个数
                    w.completedTasks++;
                    // 执行完任务之后，解锁，Worker变成闲置Worker
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally { 
            processWorkerExit(w, completedAbruptly);
        }
    }

我们看一下getTask方法是如何获得任务的：

// 如果发生了以下四件事中的任意一件，那么Worker需要被回收：
    // 1. Worker个数比线程池最大大小要大
    // 2. 线程池处于STOP状态
    // 3. 线程池处于SHUTDOWN状态并且阻塞队列为空
    // 4. 使用超时时间从阻塞队列里拿数据，并且超时之后没有拿到数据(allowCoreThreadTimeOut || workerCount > corePoolSize)
    private Runnable getTask() { 
    	// 如果使用超时时间并且也没有拿到任务的标识
        boolean timedOut = false; 
        retry:
        for (;;) { 
            int c = ctl.get();
            int rs = runStateOf(c);
    
            // 如果线程池是SHUTDOWN状态并且阻塞队列为空的话，worker数量减一，直接返回null(SHUTDOWN状态还会处理阻塞队列任务，但是阻塞队列为空的话就结束了)，
            // 如果线程池是STOP状态的话，worker数量减一，直接返回null(STOP状态不处理阻塞队列任务)[方法一开始注释的2，3两点，返回null，开始Worker回收]
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) { 
                decrementWorkerCount();
                return null;
            }
    		// 标记从队列中取任务时是否设置超时时间，如果为true说明这个worker可能需要回收，为false的话这个worker会一直存在，并且阻塞当前线程等待阻塞队列中有数据
            boolean timed;
    
            for (;;) { 
                int wc = workerCountOf(c); // 得到当前线程池Worker个数
                // allowCoreThreadTimeOut属性默认为false，表示线程池中的核心线程在闲置状态下还保留在池中；如果是true表示核心线程使用keepAliveTime这个参数来作为超时时间
                // 如果worker数量比基本大小要大的话，timed就为true，需要进行回收worker
                timed = allowCoreThreadTimeOut || wc > corePoolSize; 
    			// 方法一开始注释的1，4两点，会进行下一步worker数量减一
                if (wc <= maximumPoolSize && ! (timedOut && timed)) 
                    break;
                if (compareAndDecrementWorkerCount(c))
                	 // worker数量减一，返回null，之后会进行Worker回收工作
                    return null;
                c = ctl.get();  // 重新检查线程池状态
                // 线程池状态改变的话重新开始外部循环，否则继续内部循环
                if (runStateOf(c) != rs) 
                    continue retry;
            }
    
            try { 
                // 如果需要设置超时时间，使用poll方法，否则使用take方法一直阻塞等待阻塞队列新进数据
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) { 
            	// 闲置Worker被中断
                timedOut = false; 
            }
        }
    }

整个流程如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMzI5MzM0MzI_size_16_color_FFFFFF_t_70 2]

如果getTask返回的是null，那说明阻塞队列已经没有任务并且当前调用getTask的Worker需要被回收，那么会调用processWorkerExit方法进行回收，至此，该线程结束自己的使命，从线程池中“消失”。

private void processWorkerExit(Worker w, boolean completedAbruptly) { 
        if (completedAbruptly) // 如果Worker没有正常结束流程调用processWorkerExit方法，worker数量减一。如果是正常结束的话，在getTask方法里worker数量已经减一了
            decrementWorkerCount();
    
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock(); // 加锁，防止并发问题
        try { 
            completedTaskCount += w.completedTasks; // 记录总的完成任务数
            workers.remove(w); // 线程池的worker集合删除掉需要回收的Worker
        } finally { 
            mainLock.unlock(); // 解锁
        }
    
        tryTerminate(); // 尝试结束线程池
    
        int c = ctl.get();
        if (runStateLessThan(c, STOP)) {   // 如果线程池还处于RUNNING或者SHUTDOWN状态
            if (!completedAbruptly) {  // Worker是正常结束流程的话
                int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
                if (min == 0 && ! workQueue.isEmpty())
                    min = 1;
                if (workerCountOf(c) >= min)
                    return; // 不需要新开一个Worker
            }
            // 新开一个Worker代替原先的Worker
            // 新开一个Worker需要满足以下3个条件中的任意一个：
            // 1. 用户执行的任务发生了异常
            // 2. Worker数量比线程池基本大小要小
            // 3. 阻塞队列不空但是没有任何Worker在工作
            addWorker(null, false);
        }
    }

在回收Worker的时候线程池会尝试结束自己的运行，tryTerminate方法：

final void tryTerminate() { 
        for (;;) { 
            int c = ctl.get();
            // 满足3个条件中的任意一个，不终止线程池
            // 1. 线程池还在运行，不能终止
            // 2. 线程池处于TIDYING或TERMINATED状态，说明已经在关闭了，不允许继续处理
            // 3. 线程池处于SHUTDOWN状态并且阻塞队列不为空，这时候还需要处理阻塞队列的任务，不能终止线程池
            if (isRunning(c) ||
                runStateAtLeast(c, TIDYING) ||
                (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
                return;
            // 走到这一步说明线程池已经不在运行，阻塞队列已经没有任务，但是还要回收正在工作的Worker
            if (workerCountOf(c) != 0) { 
                 // 由于线程池不运行了，调用了线程池的关闭方法，在解释线程池的关闭原理的时候会说道这个方法
                interruptIdleWorkers(ONLY_ONE); // 中断闲置Worker，直到回收全部的Worker。这里没有那么暴力，只中断一个，中断之后退出方法，中断了Worker之后，Worker会回收，然后还是会调用tryTerminate方法，如果还有闲置线程，那么继续中断
                return;
            }
            // 走到这里说明worker已经全部回收了，并且线程池已经不在运行，阻塞队列已经没有任务。可以准备结束线程池了
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock(); // 加锁，防止并发
            try { 
                if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {  // cas操作，将线程池状态改成TIDYING
                    try { 
                        terminated(); // 调用terminated方法
                    } finally { 
                        ctl.set(ctlOf(TERMINATED, 0)); // terminated方法调用完毕之后，状态变为TERMINATED
                        termination.signalAll();
                    }
                    return;
                }
            } finally { 
                mainLock.unlock(); // 解锁
            }
            // else retry on failed CAS
        }
    }

下面来做一个总结  
线程池构造完毕之后，如果用户调用了execute或者submit方法的时候，最后都会使用execute方法执行。

execute方法内部分3种情况处理任务：

1.  如果当前正在执行的Worker数量比corePoolSize(基本大小)要小。直接创建一个新的Worker执行任务，会调用addWorker方法
2.  如果当前正在执行的Worker数量大于等于corePoolSize(基本大小)。将任务放到阻塞队列里，如果阻塞队列没满并且状态是RUNNING的话，直接丢到阻塞队列，否则执行第3步
3.  丢到阻塞失败的话，会调用addWorker方法尝试起一个新的Worker去阻塞队列拿任务并执行任务，如果这个新的Worker创建失败，调用reject方法

线程池中的这个基本大小指的是Worker的数量。一个Worker是一个Runnable的实现类，会被当做一个线程进行启动。Worker内部带有一个Runnable属性firstTask，这个firstTask可以为null，为null的话Worker会去阻塞队列拿任务执行，否则会先执行这个任务，执行完毕之后再去阻塞队列继续拿任务执行。

所以说如果Worker数量超过了基本大小，那么任务都会在阻塞队列里，当Worker执行完了它的第一个任务之后，就会去阻塞队列里拿其他任务继续执行。

Worker在执行的时候会根据一些参数进行调节，比如Worker数量超过了线程池基本大小或者超时时间到了等因素，这个时候Worker会被线程池回收，线程池会尽量保持内部的Worker数量不超过基本大小。

另外Worker执行任务的时候调用的是Runnable的run方法，而不是start方法，调用了start方法就相当于另外再起一个线程了。

Worker在回收的时候会尝试终止线程池。尝试关闭线程池的时候，会检查是否还有Worker在工作，检查线程池的状态，没问题的话会将状态过度到TIDYING状态，之后调用terminated方法，terminated方法调用完成之后将线程池状态更新到TERMINATED。

## ThreadPoolExecutor的关闭 ##

线程池的启动过程分析好了之后，接下来看线程池的关闭操作：  
shutdown方法，关闭线程池，关闭之后阻塞队列里的任务不受影响，会继续被Worker处理，但是新的任务不会被接受：

public void shutdown() { 
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock(); // 关闭的时候需要加锁，防止并发
        try { 
            checkShutdownAccess(); // 检查关闭线程池的权限
            advanceRunState(SHUTDOWN); // 把线程池状态更新到SHUTDOWN
            interruptIdleWorkers(); // 中断闲置的Worker
            onShutdown(); // 钩子方法，默认不处理。ScheduledThreadPoolExecutor会做一些处理
        } finally { 
            mainLock.unlock(); // 解锁
        }
        tryTerminate(); // 尝试结束线程池，上面已经分析过了
    }

interruptIdleWorkers方法，注意，这个方法打断的是闲置Worker，打断闲置Worker之后，getTask方法会返回null，然后Worker会被回收。那什么是闲置Worker呢？

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

所以Worker被设计成一个AQS是为了根据Worker的锁来判断是否是闲置线程，是否可以被强制中断。

下面我们看下interruptIdleWorkers方法：

// 调用他的一个重载方法，传入了参数false，表示要中断所有的正在运行的闲置Worker，如果为true表示只打断一个闲置Worker
    private void interruptIdleWorkers() { 
        interruptIdleWorkers(false);
    }
    
    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() && w.tryLock()) {  // Worker中的线程没有被打断并且Worker可以获取锁，这里Worker能获取锁说明Worker是个闲置Worker，在阻塞队列里拿数据一直被阻塞，没有数据进来。如果没有获取到Worker锁，说明Worker还在执行任务，不进行中断(shutdown方法不会中断正在执行的任务)
                    try { 
                        t.interrupt();  // 中断Worker线程
                    } catch (SecurityException ignore) { 
                    } finally { 
                        w.unlock(); // 释放Worker锁
                    }
                }
                if (onlyOne) // 如果只打断1个Worker的话，直接break退出，否则，遍历所有的Worker
                    break;
            }
        } finally { 
            mainLock.unlock(); // 解锁
        }
    }

shutdown方法将线程池状态改成SHUTDOWN，线程池还能继续处理阻塞队列里的任务，并且会回收一些闲置的Worker。但是shutdownNow方法不一样，它会把线程池状态改成STOP状态，这样不会处理阻塞队列里的任务，也不会处理新的任务：

// shutdownNow方法会有返回值的，返回的是一个任务列表，而shutdown方法没有返回值
    public List<Runnable> shutdownNow() { 
        List<Runnable> tasks;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock(); // shutdownNow操作也需要加锁，防止并发
        try { 
            checkShutdownAccess(); // 检查关闭线程池的权限
            advanceRunState(STOP); // 把线程池状态更新到STOP
            interruptWorkers(); // 中断Worker的运行
            tasks = drainQueue();
        } finally { 
            mainLock.unlock(); // 解锁
        }
        tryTerminate(); // 尝试结束线程池，上面已经分析过了
        return tasks;
    }

shutdownNow的中断和shutdown方法不一样，调用的是interruptWorkers方法：

private void interruptWorkers() { 
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock(); // 中断Worker需要加锁，防止并发
        try { 
            for (Worker w : workers)
                w.interruptIfStarted(); // 中断Worker的执行
        } finally { 
            mainLock.unlock(); // 解锁
        }
    }

Worker的interruptIfStarted方法中断Worker的执行：

void interruptIfStarted() { 
       Thread t;
       // Worker无论是否被持有锁，只要还没被中断，那就中断Worker
       if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) { 
           try { 
               t.interrupt(); // 强行中断Worker的执行
           } catch (SecurityException ignore) { 
           }
       }
    }

线程池关闭总结：

线程池的关闭主要是两个方法，shutdown和shutdownNow方法。

shutdown方法会更新状态到SHUTDOWN，不会影响阻塞队列里任务的执行，但是不会执行新进来的任务。同时也会回收闲置的Worker，闲置Worker的定义上面已经说过了。

shutdownNow方法会更新状态到STOP，会影响阻塞队列的任务执行，也不会执行新进来的任务。同时会回收所有的Worker。

参考：  
https://fangjian0423.github.io/2016/03/22/java-threadpool-analysis/

https://mp.weixin.qq.com/s?\_\_biz=MzI4Njc5NjM1NQ==&mid=2247487936&idx=1&sn=5c9795ad21e22080cb12cc5c0153208a&chksm=ebd62eecdca1a7fae5dd1f79bbff4a102bb1f9b6058d77e3cfc2be5e19c10edd9a3920d13d01&mpshare=1&scene=24&srcid=\#rd

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMzI5MzM0MzI_size_16_color_FFFFFF_t_70]: /images/20220526/21756531dc1f42e5b1ce35ab409732a6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMzI5MzM0MzI_size_16_color_FFFFFF_t_70 1]: /images/20220526/a6ffe549d04440acb8c798735d3a9901.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMzI5MzM0MzI_size_16_color_FFFFFF_t_70 2]: /images/20220526/7fe50029d3c941c3a8784913bfd90273.png