《Java并发编程的艺术》读后笔记-ThreadPoolExecutor详解（第十章）

- 日理万妓 2023-10-01 17:05 11阅读 0赞

#### 文章目录 ####

*  《Java并发编程的艺术》读后笔记-ThreadPoolExecutor详解（第十章）
 *   *  1.ThreadPoolExecutor简介
     *  2.FixedThreadPool详解
     *  3.SingleThreadExecutor详解
     *  4.CachedThreadPool详解

## 《Java并发编程的艺术》读后笔记-ThreadPoolExecutor详解（第十章） ##

### 1.ThreadPoolExecutor简介 ###

**Executor框架最核心的类是ThreadPoolExecutor，它是线程池的实现类**，主要由下列4个组件构成：

1.  `corePool`：核心线程池的大小。
2.  `maximumPool`：最大线程池的大小。
3.  `BlockingQueue`：用来暂时保存任务的工作队列。
4.  `RejectedExecutionHandler`：当ThreadPoolExecutor已经关闭或ThreadPoolExecutor已经饱和时（达到了最大线程池大小且工作队列已满），`execute()`方法将要调用的Handler。

通过Executor框架的工具类`Executors`，可以创建3种类型的ThreadPoolExecutor：

1.  `FixedThreadPool`
2.  `SingleThreadExecutor`
3.  `CachedThreadPool`

### 2.FixedThreadPool详解 ###

**FixedThreadPool被称为可重用固定线程数的线程池。**

源代码实现：

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

从源码可以看出：

1.  FixedThreadPool的corePoolSize和maximumPoolSize都被设置为创建FixedThreadPool时指定的参数`nThreads`
2.  当线程池中的线程数大于corePoolSize时，**keepAliveTime为多余的空闲线程等待新任务的最长时间**，超过这个时间后多余的线程将被终止。**这里把keepAliveTime设置为0L，意味着多余的空闲线程会被立即终止。**

`FixedThreadPool`的`execute()`方法的运行示意图：

![image-20220118133612324][]

1.  如果当前运行的线程数少于corePoolSize，则创建新线程来执行任务。
2.  在线程池完成预热之后（当前运行的线程数等于corePoolSize），将任务加入 LinkedBlockingQueue。
3.  线程执行完1中的任务后，会在循环中反复从LinkedBlockingQueue获取任务来执行。 **FixedThreadPool使用无界队列LinkedBlockingQueue作为线程池的工作队列**（队列的容量为 Integer.MAX\_VALUE）。

使用无界队列作为工作队列会对线程池带来如下影响：

1.  当线程池中的线程数达到corePoolSize后，新任务将在无界队列中等待，因此线程池中的线程数不会超过corePoolSize。
2.  由于1，使用无界队列时maximumPoolSize将是一个无效参数。
3.  由于1和2，使用无界队列时keepAliveTime将是一个无效参数。
4.  由于使用无界队列，运行中的FixedThreadPool（未执行方法shutdown()或 shutdownNow()）不会拒绝任务（不会调用RejectedExecutionHandler.rejectedExecution方法）

### 3.SingleThreadExecutor详解 ###

**SingleThreadExecutor是使用单个worker线程的Executor。**

源代码实现：

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

从源码可以看出：

1.  SingleThreadExecutor的corePoolSize和maximumPoolSize被设置为1。其他参数与 FixedThreadPool相同。
2.  **SingleThreadExecutor使用无界队列LinkedBlockingQueue作为线程池的工作队列**（队列的容量为Integer.MAX\_VALUE）。
3.  SingleThreadExecutor使用无界队列作为工作队列 对线程池带来的影响与FixedThreadPool相同，这里就不赘述了

`SingleThreadExecutor`的运行示意图：

![image-20220118134235094][]

1.  如果当前运行的线程数少于corePoolSize（即线程池中无运行的线程），则创建一个新线程来执行任务。
2.  在线程池完成预热之后（当前线程池中有一个运行的线程），将任务加入LinkedBlockingQueue。
3.  线程执行完1中的任务后，会在一个无限循环中反复从LinkedBlockingQueue获取任务来执行。

### 4.CachedThreadPool详解 ###

**CachedThreadPool是一个会根据需要创建新线程的线程池。**

源代码实现：

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

从源码可以看出：

1.  CachedThreadPool的corePoolSize被设置为0，即corePool为空。
2.  maximumPoolSize被设置为Integer.MAX\_VALUE，即**maximumPool是无界的。**
3.  这里把keepAliveTime设置为60L，意味着**CachedThreadPool中的空闲线程等待新任务的最长时间为60秒，空闲线程超过60秒后将会被终止**。
4.  FixedThreadPool和SingleThreadExecutor使用无界队列LinkedBlockingQueue作为线程池的工作队列。**CachedThreadPool使用没有容量的SynchronousQueue作为线程池的工作队列**，但 CachedThreadPool的maximumPool是无界的。这意味着，如果主线程提交任务的速度高于 maximumPool中线程处理任务的速度时，CachedThreadPool会不断创建新线程。极端情况下，CachedThreadPool会因为创建过多线程而耗尽CPU和内存资源

`CachedThreadPool`的`execute()`方法的执行示意图：

![image-20220118141748659][]

1.  首先执行`SynchronousQueue.offer`（Runnable task）。如果当前maximumPool中有空闲线程正在执行`SynchronousQueue.poll(keepAliveTime，TimeUnit.NANOSECONDS)`，那么主线程执行 offer操作与空闲线程执行的poll操作配对成功，主线程把任务交给空闲线程执行，execute()方法执行完成；否则执行下面的步骤2。
2.  当初始maximumPool为空，或者maximumPool中当前没有空闲线程时，将没有线程执行SynchronousQueue.poll（keepAliveTime，TimeUnit.NANOSECONDS）。这种情况下，步骤1将失 败。此时CachedThreadPool会创建一个新线程执行任务，execute()方法执行完成。
3.  在步骤2中新创建的线程将任务执行完后，会执行 SynchronousQueue.poll（keepAliveTime，TimeUnit.NANOSECONDS）。这个poll操作会让空闲线程最多在SynchronousQueue中等待`60`秒钟。如果60秒钟内主线程提交了一个新任务（主线程执行步骤1），那么这个空闲线程将执行主线程提交的新任务；否则，这个空闲线程将终止。由于空闲60秒的空闲线程会被终止，因此长时间保持空闲的CachedThreadPool不会使用任何资源。

**SynchronousQueue是一个没有容量的阻塞队列。每个插入操作必须等待另一 个线程的对应移除操作**，反之亦然。CachedThreadPool使用SynchronousQueue，把主线程提交的任务传递给空闲线程执行。

`CachedThreadPool`中任务传递的示意图如图：

![image-20220118142137859][]

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATEwuTEVCUk9O_size_20_color_FFFFFF_t_70_g_se_x_16]

[image-20220118133612324]: https://img-blog.csdnimg.cn/img_convert/a6b4a1b0b842aac2e4ef86b72849bd0a.png
[image-20220118134235094]: https://img-blog.csdnimg.cn/img_convert/f86509bd75e804e6e391a734fbbfa049.png
[image-20220118141748659]: https://img-blog.csdnimg.cn/img_convert/910c207ddaba35364d067bc8991d4b10.png
[image-20220118142137859]: https://img-blog.csdnimg.cn/img_convert/22bdbd0764a49fd0a25f772e95727f04.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATEwuTEVCUk9O_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/df1962a363454756a0cbda2da84cf43e.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATEwuTEVCUk9O,size_20,color_FFFFFF,t_70,g_se,x_16