Java线程池的底层实现与使用

比眉伴天荒 2021-10-23 14:11 299阅读 0赞

**正文**

前言

在我们进行开发的时候，为了充分利用系统资源，我们通常会进行多线程开发，实现起来非常简单，需要使用线程的时候就去创建一个线程（继承Thread类、实现Runnable接口、使用Callable和Future），但是这样也有一点问题，就是如果并发的线程数量很多，创建线程、销毁线程都是需要消耗时间、资源，这个时候线程池就派上用场了

# 一、四种线程池的介绍 #

Java通过Executors提供了四种线程池，分别是

**　1.newSingleThreadExecutor()**

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务都是按照指定的顺序（FIFO，LIFO，优先级）执行

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

**2.newFixedThreadExecutor()**

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待

1     public static ExecutorService newFixedThreadPool(int nThreads) { 2         return new ThreadPoolExecutor(nThreads, nThreads, 3                                       0L, TimeUnit.MILLISECONDS, 4                                       new LinkedBlockingQueue<Runnable>()); 5     }

**　3.newCachedThreadPool()**

创建一个可缓存的线程池，如果当前没有可用线程，在执行结束后缓存60s，如果不被调用则移除线程。调用execute()方法时可以重用缓存中的线程。适用于很多短期异步任务的环境，可以提高程序性能。

1     public static ExecutorService newCachedThreadPool() { 2         return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 3                                       60L, TimeUnit.SECONDS, 4                                       new SynchronousQueue<Runnable>()); 5     }

**4.newScheduledThreadPool()（在ScheduleThreadPoolExecutor类中，ThreadPoolExecutor的子类）**

创建一个定长线程池，支持定时及周期性任务执行

1     public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) { 2         return new ScheduledThreadPoolExecutor(corePoolSize); 3 } 4 
    5     public ScheduledThreadPoolExecutor(int corePoolSize) { 6         super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, 7               new DelayedWorkQueue()); 8     }

### 　线程池的使用 ###

使用方式一（不提倡我们直接使用ThreadPoolExecutor，而是使用Executors类中提供的几个静态方法来创建线程池）：

1         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS, 2                 new ArrayBlockingQueue<Runnable>(5)); 3         threadPoolExecutor.execute(new Runnable() { 4 @Override 5             public void run() { 6                 
    7 } 8         });

使用方式二：

1         ExecutorService executorService1 = Executors.newFixedThreadPool(3); 2         ExecutorService executorService2 = Executors.newSingleThreadExecutor(); 3         ExecutorService executorService3 = Executors.newCachedThreadPool(); 4         ExecutorService executorService4 = Executors.newScheduledThreadPool(3); 5         executorService1.execute(new Runnable() { 6 @Override 7             public void run() { 8                 
     9 } 10         });

ExecutorService是真正的线程池接口，所以我们在通过Executors创建各种线程时，都是采用上述代码所示的方式

# 二、线程池的底层类与接口 #

**在介绍线程池的实现机制之前，先了解一下线程池重要的类或接口**

**　　ExecutorService**是真正的线程池接口

**Executors**是静态工厂的功能，生产各种类型线程池

**Executor**是线程池的顶级接口，只是一个执行线程的工具，只提供一个execute(Runnable command)的方法，真正的线程池接口是**ExecutorService**

**AbstractExecutorService**实现了**ExecutorService**接口，实现了其中大部分的方法（有没有实现的方法，所以被声明为Abstract）

**ThreadPoolExecutor**，继承了**AbstractExecutorService**，是**ExecutorService**的默认实现

## 1、ThreadPoolExecutor类 ##

### （1）构造函数 ###

java.uitl.concurrent.ThreadPoolExecutor类是线程池中最核心的一个类，因此如果要透彻地了解Java中的线程池，必须先了解这个类。

在ThreadPoolExecutor类中提供了四个构造方法（前面三个构造器都是调用第四个构造器进行的初始化工作）：

1 public class ThreadPoolExecutor extends AbstractExecutorService { 2 ..... 3     public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit, 4             BlockingQueue<Runnable> workQueue); 5  
     6     public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit, 7             BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory); 8  
     9     public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit, 10             BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler); 11  
    12     public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit, 13         BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler); 14 ... 15 }

**构造器中各个参数的含义：**

*  **corePoolSize**：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
 *  **maximumPoolSize**：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程
 *  **keepAliveTime**：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
 *  **unit**：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：
    
        TimeUnit.DAYS;               //天
        TimeUnit.HOURS;             //小时
        TimeUnit.MINUTES;           //分钟
        TimeUnit.SECONDS;           //秒
        TimeUnit.MILLISECONDS;      //毫秒
        TimeUnit.MICROSECONDS;      //微妙
        TimeUnit.NANOSECONDS;       //纳秒
 *  **workQueue**：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。
 *  **threadFactory**：线程工厂，主要用来创建线程；
 *  **handler：表示当拒绝处理任务时的策略，有以下四种取值：**

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 
    　　ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 
    　　ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
    　　ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

### （2）ThreadPoolExecutor方法 ###

1 execute() 2 submit() 3 shutdown() 4 shutdownNow() 5 getQueue() 6 getPoolSize() 7 getActiveCount() 8 getCompletedTaskCount()

execute()方法实际上是Executor中声明的方法，在ThreadPoolExecutor进行了具体的实现，这个方法是ThreadPoolExecutor的核心方法，通过这个方法可以向线程池提交一个任务，交由线程池去执行。

submit()方法是在ExecutorService中声明的方法，在AbstractExecutorService就已经有了具体的实现，在ThreadPoolExecutor中并没有对其进行重写，这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，去看submit()方法的实现，会发现它实际上还是调用的execute()方法，只不过它利用了Future来获取任务执行结果（Future相关内容将在下一篇讲述）。

shutdown()和shutdownNow()是用来关闭线程池的。

getQueue() 、getPoolSize() 、getActiveCount()、getCompletedTaskCount()等获取与线程池相关属性的方法

还有在下文提到的runwork()、addwork()、processworkerExit() 方法等等

## 2、AbstractExecutorService类 ##

下面我们看一下AbstractExecutorService的具体方法

1 public abstract class AbstractExecutorService implements ExecutorService { 2 
     3     protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {...}; 4     protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {...}; 5     public Future<?> submit(Runnable task) {}; 6     public <T> Future<T> submit(Runnable task, T result) {...}; 7     public <T> Future<T> submit(Callable<T> task) {...}; 8     private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks, 9                             boolean timed, long nanos) 10         throws InterruptedException, ExecutionException, TimeoutException {...}; 11     public <T> T invokeAny(Collection<? extends Callable<T>> tasks) 12         throws InterruptedException, ExecutionException {...}; 13     public <T> T invokeAny(Collection<? extends Callable<T>> tasks, 14                            long timeout, TimeUnit unit) 15         throws InterruptedException, ExecutionException, TimeoutException {...}; 16     public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) 17         throws InterruptedException {...}; 18     public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, 19                                          long timeout, TimeUnit unit) 20         throws InterruptedException {...}; 21 }

AbstractExecutorService是一个抽象类，它实现了ExecutorService接口。

## 3、ExecutorService接口 ##

1 public interface ExecutorService extends Executor { 2  
     3     void shutdown(); 4     boolean isShutdown(); 5     boolean isTerminated(); 6     boolean awaitTermination(long timeout, TimeUnit unit) 7         throws InterruptedException; 8     <T> Future<T> submit(Callable<T> task); 9     <T> Future<T> submit(Runnable task, T result); 10     Future<?> submit(Runnable task); 11     <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) 12         throws InterruptedException; 13     <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, 14                                   long timeout, TimeUnit unit) 15         throws InterruptedException; 16  
    17     <T> T invokeAny(Collection<? extends Callable<T>> tasks) 18         throws InterruptedException, ExecutionException; 19     <T> T invokeAny(Collection<? extends Callable<T>> tasks, 20                     long timeout, TimeUnit unit) 21         throws InterruptedException, ExecutionException, TimeoutException; 22 }

而ExecutorService又是继承了Executor接口，我们看一下Executor接口的实现：

## 4、Executor接口 ##

1 public interface Executor { 2     void execute(Runnable command); 3 }

### 上述类与接口之间的关系 ###

Executor是一个顶层接口，在它里面只声明了一个方法execute(Runnable)，返回值为void，参数为Runnable类型，从字面意思可以理解，就是用来执行传进去的任务的；

然后ExecutorService接口继承了Executor接口，并声明了一些方法：submit、invokeAll、invokeAny以及shutDown等；

抽象类AbstractExecutorService实现了ExecutorService接口，基本实现了ExecutorService中声明的所有方法；

然后ThreadPoolExecutor继承了类AbstractExecutorService。[  
][Link 1]

# 三、线程池的底层实现原理 #

## 1、线程池的状态 ##

1 private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); 2     private static final int COUNT_BITS = Integer.SIZE - 3; 3     private static final int CAPACITY   = (1 << COUNT_BITS) - 1; 4 
     5     // runState is stored in the high-order bits
     6     private static final int RUNNING    = -1 << COUNT_BITS; 7     private static final int SHUTDOWN   =  0 << COUNT_BITS; 8     private static final int STOP       =  1 << COUNT_BITS; 9     private static final int TIDYING    =  2 << COUNT_BITS; 10     private static final int TERMINATED =  3 << COUNT_BITS; 11 
    12     // Packing and unpacking ctl
    13     private static int runStateOf(int c)     { return c & ~CAPACITY; } 14     private static int workerCountOf(int c)  { return c & CAPACITY; } 15     private static int ctlOf(int rs, int wc) { return rs | wc; }

其中ctl这个AtomicInteger的功能很强大，其高3位用于维护线程池运行状态，低29位维护线程池中线程数量

1、**RUNNING**：-1<<COUNT\_BITS，即高3位为1，低29位为0，该状态的线程池会接收新任务，也会处理在阻塞队列中等待处理的任务

2、**SHUTDOWN**：0<<COUNT\_BITS，即高3位为0，低29位为0，该状态的线程池不会再接收新任务，但还会处理已经提交到阻塞队列中等待处理的任务

3、**STOP**：1<<COUNT\_BITS，即高3位为001，低29位为0，该状态的线程池不会再接收新任务，不会处理在阻塞队列中等待的任务，而且还会中断正在运行的任务

4、**TIDYING**：2<<COUNT\_BITS，即高3位为010，低29位为0，所有任务都被终止了，workerCount为0，为此状态时还将调用terminated()方法

5、**TERMINATED**：3<<COUNT\_BITS，即高3位为100，低29位为0，terminated()方法调用完成后变成此状态

这些状态均由int型表示，大小关系为 RUNNING<SHUTDOWN<STOP<TIDYING<TERMINATED，这个顺序基本上也是遵循线程池从 运行 到 终止这个过程。

**runStateOf(int c)  方法**：c & 高3位为1，低29位为0的~CAPACITY，用于获取高3位保存的线程池状态

**workerCountOf(int c)方法**：c & 高3位为0，低29位为1的CAPACITY，用于获取低29位的线程数量

**ctlOf(int rs, int wc)方法**：参数rs表示runState，参数wc表示workerCount，即根据runState和workerCount打包合并成ctl

## 2、执行过程 ##

一个任务从提交到执行完毕经历过程如下：

第一步：如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务；

第二步：如果当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般来说是任务缓存队列已满），则会尝试创建新的线程去执行这个任务；

第三步：如果线程池中的线程数量大于等于corePoolSize，且队列workQueue已满，但线程池中的线程数量小于maximumPoolSize，则会创建新的线程来处理被添加的任务

第四步：如果当前线程池中的线程数目达到maximumPoolSize，则会采取任务拒绝策略进行处理；

## 3、任务拒绝策略 ##

当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略，通常有以下四种策略：

*  ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
 *  ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
 *  ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
 *  ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

## 4、在执行过程中所涉及到的方法 ##

### （1）execute(Runnable command)（提交任务） ###

在ThreadPoolExecutor类中，最核心的任务提交方法是execute()方法，虽然通过submit也可以提交任务，但是实际上submit方法里面最终调用的还是execute()方法，所以我们只需要研究execute()方法的实现

1 public void execute(Runnable command) { 2         if (command == null) 3             throw new NullPointerException(); 4          int c = ctl.get(); 5         if (workerCountOf(c) < corePoolSize) { 6             if (addWorker(command, true)) 7                 return; 8             c = ctl.get(); 9 } 10         if (isRunning(c) && workQueue.offer(command)) { 11             int recheck = ctl.get(); 12             if (! isRunning(recheck) && remove(command)) 13 reject(command); 14             else if (workerCountOf(recheck) == 0) 15                 addWorker(null, false); 16 } 17         else if (!addWorker(command, false)) 18 reject(command); 19     }

源码解析：

1、如果线程池当前线程数量少于corePoolSize，则addWorker(command, true)创建新worker线程，如创建成功返回，如没创建成功，则执行后续步骤；  
    addWorker(command, true)失败的原因可能是：  
    A、线程池已经shutdown，shutdown的线程池不再接收新任务  
    B、workerCountOf(c) < corePoolSize 判断后，由于并发，别的线程先创建了worker线程，导致workerCount>=corePoolSize  
2、如果线程池还在running状态，将task加入workQueue阻塞队列中，如果加入成功，进行double-check，如果加入失败（可能是队列已满），则执行后续步骤；  
    double-check主要目的是判断刚加入workQueue阻塞队列的task是否能被执行  
    A、如果线程池已经不是running状态了，应该拒绝添加新任务，从workQueue中删除任务  
    B、如果线程池是运行状态，或者从workQueue中删除任务失败（刚好有一个线程执行完毕，并消耗了这个任务），确保还有线程执行任务（只要有一个就够了）  
3、如果线程池不是running状态 或者 无法入队列，尝试开启新线程，扩容至maxPoolSize，如果addWork(command, false)失败了，拒绝当前command

### （2）addwork(Runnable firstTask,boolean core)（添加任务） ###

**参数说明：**

firstTask：worker线程的初始任务，可以为空

core：true（将corePoolSize作为上限），false（将maximumPoolSize作为上限）

**addWorker方法有4种传参的方式：**

1、addWorker(command, true)

2、addWorker(command, false)

3、addWorker(null, false)

4、addWorker(null, true)

在execute方法中就使用了前3种，结合这个核心方法进行以下分析  
    第一个：线程数小于corePoolSize时，放一个需要处理的task进Workers Set。如果Workers Set长度超过corePoolSize，就返回false  
    第二个：当队列被放满时，就尝试将这个新来的task直接放入Workers Set，而此时Workers Set的长度限制是maximumPoolSize。如果线程池也满了的话就返回false  
    第三个：放入一个空的task进workers Set，长度限制是maximumPoolSize。这样一个task为空的worker在线程执行的时候会去任务队列里拿任务，这样就相当于创建了一个新的线程，只是没有马上分配任务  
    第四个：这个方法就是放一个null的task进Workers Set，而且是在小于corePoolSize时，如果此时Set中的数量已经达到corePoolSize那就返回false，什么也不干。实际使用中是在prestartAllCoreThreads()方法，这个方法用来为线程池预先启动corePoolSize个worker等待从workQueue中获取任务执行

源码解析：

1、判断线程池当前是否为可以添加worker线程的状态，可以则继续下一步，不可以return false：  
    A、线程池状态>shutdown，可能为stop、tidying、terminated，不能添加worker线程  
    B、线程池状态==shutdown，firstTask不为空，不能添加worker线程，因为shutdown状态的线程池不接收新任务  
    C、线程池状态==shutdown，firstTask==null，workQueue为空，不能添加worker线程，因为firstTask为空是为了添加一个没有任务的线程再从workQueue获取task，而workQueue为空，说明添加无任务线程已经没有意义  
2、线程池当前线程数量是否超过上限（corePoolSize 或 maximumPoolSize），超过了return false，没超过则对workerCount+1，继续下一步  
3、在线程池的ReentrantLock保证下，向Workers Set中添加新创建的worker实例，添加完成后解锁，并启动worker线程，如果这一切都成功了，return true，如果添加worker入Set失败或启动失败，调用addWorkerFailed()逻辑

**其中，线程池会把每个线程封装成一个Worker对象，由addWorker(Runnable firstTask, boolean core)方法控制，firstTask代表线程池首要执行的任务，core代表是否使用corePoolSize参数作为线程池最大标记。**

### （3）内部类worker ###

Worker类本身既实现了Runnable，又继承了AbstractQueuedSynchronizer（以下简称AQS），所以其既是一个可执行的任务，又可以达到锁的效果  
**　　new Worker()**  
　　　　1、将AQS的state置为-1，在runWoker()前不允许中断  
　　　　2、待执行的任务会以参数传入，并赋予firstTask  
　　　　3、用Worker这个Runnable创建Thread

之所以Worker自己实现Runnable，并创建Thread，在firstTask外包一层，是因为要通过Worker控制中断，而firstTask这个工作任务只是负责执行业务  
**　　Worker控制中断主要有以下几方面：**  
　　　　1、初始AQS状态为-1，此时不允许中断interrupt()，只有在worker线程启动了，执行了runWoker()，将state置为0，才能中断  
    不允许中断体现在：  
    　　　　A、shutdown()线程池时，会对每个worker tryLock()上锁，而Worker类这个AQS的tryAcquire()方法是固定将state从0->1，故初始状态state==-1时tryLock()失败，没发interrupt()  
    　　　　B、shutdownNow()线程池时，不用tryLock()上锁，但调用worker.interruptIfStarted()终止worker，interruptIfStarted()也有state>0才能interrupt的逻辑  
　　　　2、为了防止某种情况下，在运行中的worker被中断，runWorker()每次运行任务时都会lock()上锁，而shutdown()这类可能会终止worker的操作需要先获取worker的锁，这样就防止了中断正在运行的线程

Worker实现的AQS为不可重入锁，为了是在获得worker锁的情况下再进入其它一些需要加锁的方法

**　　Worker和Task的区别：**  
　　Worker是线程池中的线程，而Task虽然是runnable，但是并没有真正执行，只是被Worker调用了run方法，后面会看到这部分的实现。

### （4）runwork(Worker w)（执行任务） ###

1、Worker线程启动后，通过Worker类的run()方法调用runWorker(this)  
　　2、执行任务之前，首先worker.unlock()，将AQS的state置为0，允许中断当前worker线程  
　　3、开始执行firstTask，调用task.run()，在执行任务前会上锁wroker.lock()，在执行完任务后会解锁，为了防止在任务运行时被线程池一些中断操作中断  
　　4、在任务执行前后，可以根据业务场景自定义beforeExecute() 和 afterExecute()方法  
　　5、无论在beforeExecute()、task.run()、afterExecute()发生异常上抛，都会导致worker线程终止，进入processWorkerExit()处理worker退出的流程  
　　6、如正常执行完当前task后，会通过getTask()从阻塞队列中获取新任务，当队列中没有任务，且获取任务超时，那么当前worker也会进入退出流程

### （5）getTask()（获取任务） ###

1、首先判断是否可以满足从workQueue中获取任务的条件，不满足return null  
    　　　A、线程池状态是否满足：  
        　　　（a）shutdown状态 + workQueue为空 或 stop状态，都不满足，因为被shutdown后还是要执行workQueue剩余的任务，但workQueue也为空，就可以退出了  
        　　　（b）stop状态，shutdownNow()操作会使线程池进入stop，此时不接受新任务，中断正在执行的任务，workQueue中的任务也不执行了，故return null返回  
    　　　B、线程数量是否超过maximumPoolSize 或 获取任务是否超时  
        　　　（a）线程数量超过maximumPoolSize可能是线程池在运行时被调用了setMaximumPoolSize()被改变了大小，否则已经addWorker()成功不会超过maximumPoolSize  
        　　　（b）如果 当前线程数量>corePoolSize，才会检查是否获取任务超时，这也体现了当线程数量达到maximumPoolSize后，如果一直没有新任务，会逐渐终止worker线程直到corePoolSize  
　　2、如果满足获取任务条件，根据是否需要定时获取调用不同方法：  
    　　　A、workQueue.poll()：如果在keepAliveTime时间内，阻塞队列还是没有任务，返回null  
    　　　B、workQueue.take()：如果阻塞队列为空，当前线程会被挂起等待；当队列中有任务加入时，线程被唤醒，take方法返回任务  
　　3、在阻塞从workQueue中获取任务时，可以被interrupt()中断，代码中捕获了InterruptedException，重置timedOut为初始值false，再次执行第1步中的判断，满足就继续获取任务，不满足return null，会进入worker退出的流程

### （6）processWorkerExit(Worker w,boolean completedAbruptly)（worker线程退出） ###

**　　参数：**  
    　　worker：                      要结束的worker  
    　　completedAbruptly： 是否突然完成（是否因为异常退出）  
**　　执行流程：**  
　　　　1、worker数量-1  
   　　　　 A、如果是突然终止，说明是task执行时异常情况导致，即run()方法执行时发生了异常，那么正在工作的worker线程数量需要-1  
    　　　　B、如果不是突然终止，说明是worker线程没有task可执行了，不用-1，因为已经在getTask()方法中-1了  
　　　　2、从Workers Set中移除worker，删除时需要上锁mainlock  
　　　　3、tryTerminate()：在对线程池有负效益的操作时，都需要“尝试终止”线程池，大概逻辑：  
   判断线程池是否满足终止的状态  
   　　　　 A、如果状态满足，但还有线程池还有线程，尝试对其发出中断响应，使其能进入退出流程  
   　　　　 B、没有线程了，更新状态为tidying->terminated  
　　　　4、是否需要增加worker线程，如果线程池还没有完全终止，仍需要保持一定数量的线程  
    线程池状态是running 或 shutdown  
   　　　　 A、如果当前线程是突然终止的，addWorker()  
    　　　　B、如果当前线程不是突然终止的，但当前线程数量 < 要维护的线程数量，addWorker()  
    故如果调用线程池shutdown()，直到workQueue为空前，线程池都会维持corePoolSize个线程，然后再逐渐销毁这corePoolSize个线程

本文转载自[https://www.cnblogs.com/sxkgeek/p/9343519.html][https_www.cnblogs.com_sxkgeek_p_9343519.html]

转载于:https://www.cnblogs.com/little-fly/p/10851776.html

[Link 1]: https://www.cnblogs.com/sxkgeek/p/9343519.html#_labelTop
[https_www.cnblogs.com_sxkgeek_p_9343519.html]: https://www.cnblogs.com/sxkgeek/p/9343519.html