并发编程---线程池（六）

深藏阁楼爱情的钟 2023-09-24 23:43 23阅读 0赞

### 阻塞队列的应⽤——线程池 ###

*  一 线程池基本概念
 *  二 线程池三种常⽤创建⽅式
 *   *  2.1.newFixedThreadPool线程池：
     *  2.2.newSingleThreadExecutor线程池：
     *  2.3.newCachedThreadPool线程池：
     *  2.4. 线程池代码演示
 *  三 线程池创建的七个参数
 *  四 线程池底层原理
 *   *  理解：
     *  案例图：
     *  原理图：
     *  流程图：
     *  线程池使用注意：
 *  五 线程池的拒绝策略
 *   *  AbortPolicy拒绝策略
     *  CallerRunsPolicy拒绝策略
     *  DiscardOldestPolicy拒绝策略
     *  DiscardPolicy拒绝策略
 *  六 实际⽣产使⽤哪⼀个线程池？
 *  七 ⾃定义线程池参数选择
 *  八 线程池配置工具类
 *  九线程池都有哪些状态？
 *  十 扩展链接

# 一 线程池基本概念 #

**概念：** 线程池主要是控制运⾏线程的数量，将待处理任务放到等待队列，然后创建线程执⾏这些任务。 如果超过了最⼤线程数，则等待。  
**为什么⽤线程池？**

> 10年前单核CPU电脑，假的多线程，像⻢戏团⼩丑玩多个球，CPU需要来回切换。  
> 现在是多核电脑，多个线程各⾃跑在独⽴的CPU上，不⽤切换效率⾼。

**线程池的优点：**  
线程池做的⼯作主要是控制运⾏的线程数量，处理过程中将任务放⼊队列，然后在线程创建后启动这些任务，如果线程数量超过了最⼤数量，超出数量的线程排队等候，等其他线程执⾏完毕，再从队列中取出任务来执⾏。  
**线程池的主要特点为**：线程复⽤；控制最⼤并发数；管理线程。

1.  线程复⽤：不⽤⼀直new新线程，重复利⽤已经创建的线程来降低线程的创建和销毁开销，节省系统资源。
2.  提⾼响应速度：当任务达到时，不⽤创建新的线程，直接利⽤线程池的线程。
3.  管理线程：可以控制最⼤并发数，控制线程的创建等。

**体系：** Executor→→ExecutorService→AbstractExecutorService→ThreadPoolExecutor。  
ThreadPoolExecutor是线程池创建的核⼼类。类似Arrays、Collections工具类，Executor也有自己的工具类Executors。  
![在这里插入图片描述][da10551488dd46f28e6ab4808bf94e0f.png]

![在这里插入图片描述][4f2901c85cd94949b54c1349a08030be.png]

# 二 线程池三种常⽤创建⽅式 #

## 2.1.newFixedThreadPool线程池： ##

使⽤ LinkedBlockingQueue实现，定⻓线程池。  
特点：执⾏⻓期任务性能好，创建⼀个线程池，⼀池有N个固定的线程，有固定线程数的线程  
![在这里插入图片描述][c5c8a26beb24481e81eed1e16e4357cc.png]

## 2.2.newSingleThreadExecutor线程池： ##

使⽤ LinkedBlockingQueue实现，⼀池只有⼀个线程。  
特点：⼀个任务⼀个任务的执⾏，⼀池⼀线程  
![在这里插入图片描述][cc157d139a864acc850b1c592d07da64.png]

## 2.3.newCachedThreadPool线程池： ##

使⽤ SynchronousQueue实现，变⻓线程池。  
特点：执⾏很多短期异步任务，线程池根据需要创建新线程，但在先前构建的线程可⽤时将重⽤他们。 可扩容，遇强则强  
![在这里插入图片描述][571e711d8c5b4b54a47ec84ebe3dddae.png]

## 2.4. 线程池代码演示 ##

**任务类**  
模拟十个客户来办理业务

private static void threadPoolTask(ExecutorService threadPool) {
        
            //模拟有10个顾客来办理业务
            try {
        
                for (int i = 1; i <= 10; i++) {
        
                    threadPool.execute(() -> {
        
                        System.out.println(Thread.currentThread().getName() + "\t办理业务");
                        try {
        
                            TimeUnit.SECONDS.sleep(1);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    });
    
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                threadPool.shutdown();
            }
        }

1.  newFixedThreadPool线程池  
    创建线程数为5，观察结果发现5个线程一起执行

//一个池子有5个工作线程，类似银行有5个受理窗口
            threadPoolTask(Executors.newFixedThreadPool(5));

![在这里插入图片描述][9e292378bb8748f2a29be747671cedc7.png]

1.  newSingleThreadExecutor线程池

创建newSingleThreadExecutor线程池，观察结果发现只有一个线程可以使用。

System.out.println("======Single Thread Pool=========");
            // //一个池子有1个工作线程，类似银行有1个受理窗口
            threadPoolTask( Executors.newSingleThreadExecutor() );

![在这里插入图片描述][5c96e0fe492344bc8f20804db71af7cb.png]

1.  newCachedThreadPool线程池：  
    创建newCachedThreadPool，观察结果有10个客户，就有<=10个线程执行任务。有可能业务员办事快，接着又给其他客户办理业务

System.out.println("=====Cached Thread Pool=======");
            // //不定量线程，一个池子有N个工作线程，类似银行有N个受理窗口
            threadPoolTask( Executors.newCachedThreadPool() );

![在这里插入图片描述][5712bc114d1f498bba866aa9c71c947f.png]  
**问题：**  
上述我们使用10个客户来模拟，如果用100个呢，我们来观察结果  
![在这里插入图片描述][9afea846b5d1475d86db077f557fa854.png]

# 三 线程池创建的七个参数 #

![在这里插入图片描述][eacca83213b5426ab8a522f774272663.png]

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>意义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>corePoolSize</td> 
   <td>线程池中的常驻核⼼线程数</td> 
  </tr> 
  <tr> 
   <td>maximumPoolSize</td> 
   <td><code>线程池中能够容纳同时并发的最⼤线程数</code>，此值必须⼤于等于1</td> 
  </tr> 
  <tr> 
   <td>keepAliveTime</td> 
   <td><code>多余的空闲线程的存活时间</code>，当前池中线程数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余线程会被销毁直到只剩下corePoolSize个线程为⽌</td> 
  </tr> 
  <tr> 
   <td>unit</td> 
   <td><code>keepAliveTime存活时间的单位</code></td> 
  </tr> 
  <tr> 
   <td>workQueue</td> 
   <td><code>任务队列</code>，存放已提交但尚未执⾏的任务</td> 
  </tr> 
  <tr> 
   <td>threadFactory</td> 
   <td>表示<code>⽣成线程池中⼯作线程的线程⼯⼚</code>，⽤于创建线程，⼀般默认的即可</td> 
  </tr> 
  <tr> 
   <td>handler</td> 
   <td><code>拒绝策略</code>，表示当队列满了，并且⼯作线程⼤于等于线程池的最⼤线程数（maximumPoolSize）时，如何来拒绝请求执⾏的runnable的策略</td> 
  </tr> 
 </tbody> 
</table>

# 四 线程池底层原理 #

## 理解： ##

线程池的创建参数，就像⼀个银⾏。

1.  `corePoolSize`就像银⾏的“当值窗⼝“，⽐如今天有2位柜员在受理客户请求（任务）。
2.  如果超过2个客户，那么新的客户就会在等候区（等待队列`workQueue`）等待。
3.  当等候区也满了，这个时候就要开启“加班窗⼝”，让其它3位柜员来加班，此时达到最⼤窗⼝`maximumPoolSize`，为5个。
4.  如果开启了所有窗⼝，等候区依然满员，此时就应该启动”拒绝策略`handler` ，告诉不断涌⼊的客户， 叫他们不要进⼊，已经爆满了。
5.  由于不再涌⼊新客户，办完事的客户增多，窗⼝开始空闲，这个时候就通过 `keepAlivetTime`将多余的3个”加班窗⼝“取消，恢复到2个”当值窗⼝“

## 案例图： ##

![在这里插入图片描述][59d6bc332889464c85f8c558a61b24e1.png]

## 原理图： ##

上⾯银⾏的例⼦，实际上就是线程池的⼯作原理。  
![在这里插入图片描述][a8cdce14180742cea6118771a1f07e4a.png]

## 流程图： ##

![在这里插入图片描述][3a3274430d59471dac7b6f96828a4773.png]  
**流程：**

> 1.  在创建了线程池后，开始等待请求。
> 2.  当调⽤`execute()`⽅法添加⼀个请求任务时，线程池会做出如下判断：  
>     2.1 如果正在运⾏的线程数量⼩于`corePoolSize`，那么⻢上创建核⼼线程运⾏执⾏这个任务；  
>     2.2 如果正在运⾏的线程数量⼤于或等于`corePoolSize`，那么将这个任务放⼊队列；  
>     2.3 如果这个时候等待队列已满，且正在运⾏的线程数量⼩于`maximumPoolSize` ，那么还是要创  
>     建⾮核⼼线程⽴刻运⾏这个任务；  
>     2.4 如果这个时候等待队列已满，且正在运⾏的线程数量⼤于或等于 `maximumPoolSize`，那么线程池会启动饱和拒绝策略来执⾏。
> 3.  当⼀个线程完成任务时，它会从等待队列中取出下⼀个任务来执⾏。
> 4.  当⼀个线程⽆事可做超过⼀定的时间（ `keepAliveTime`）后，线程会判断：  
>     如果当前运⾏的线程数⼤于 `corePoolSize`，那么这个⾮核⼼线程就被停掉。当线程池的所有任  
>     务完成后，它最终会收缩到`corePoolSize`的⼤⼩。

## 线程池使用注意： ##

《Java 开发⼿册》是阿⾥巴巴集团技术团队：

![在这里插入图片描述][9240017fd92847f890ad1c00d234d501.png]

# 五 线程池的拒绝策略 #

![在这里插入图片描述][996164f812384c798e0a50d317a0080f.png]  
**当等待队列满时，且达到最⼤线程数，再有新任务到来，就需要启动拒绝策略。JDK提供了四种拒绝策  
略，分别是：**

1.  `AbortPolicy`：默认的策略，直接抛出 RejectedExecutionException异常，阻⽌系统正常运⾏。
2.  `CallerRunsPolicy`：既不会抛出异常，也不会终⽌任务，⽽是将任务返回给调⽤者，从⽽降低新任务的流量。
3.  `DiscardOldestPolicy`：抛弃队列中等待最久的任务，然后把当前任务加⼊队列中尝试再次提交任务。
4.  `DiscardPolicy`：该策略默默地丢弃⽆法处理的任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的⼀种策略。

## AbortPolicy拒绝策略 ##

![在这里插入图片描述][6d3542b087734a839d95c61d228f5c2a.png]

## CallerRunsPolicy拒绝策略 ##

![在这里插入图片描述][d59e6369d4df4d1bba7b89290b36578d.png]

## DiscardOldestPolicy拒绝策略 ##

![在这里插入图片描述][c727730498764cacab6e8b866f7c89ed.png]

## DiscardPolicy拒绝策略 ##

![在这里插入图片描述][b13ffd1feb694d7fbfaa66e92eb79549.png]

# 六 实际⽣产使⽤哪⼀个线程池？ #

**单⼀、可变、定⻓都不⽤**！原因就是`FixedThreadPool`和 `SingleThreadExecutor`底层都是⽤ `LinkedBlockingQueue`实现的，这个队列最⼤⻓度为 `Integer.MAX_VALUE`，显然会导致`OOM`。所以实际⽣产⼀般⾃⼰通过的7个参数，⾃定义线程池

System.out.println("=====Custom Thread Pool=======");
            threadPoolTask( new ThreadPoolExecutor(
                    2,
                    5,
                    1L,
                    TimeUnit.SECONDS,
                    new LinkedBlockingQueue<>(3),
                    Executors.defaultThreadFactory(),
                    new ThreadPoolExecutor.DiscardPolicy()
            ));

结果分析![在这里插入图片描述][b6e6445f851d442e9f280e9300f16715.png]  
![在这里插入图片描述][32e1afc360234b9da33c75170825c305.png]

# 七 ⾃定义线程池参数选择 #

对于CPU密集型任务，最⼤线程数是CPU线程数+1。  
对于IO密集型任务（文件上传下载），尽量多配点，可以是CPU线程数\*2，或者CPU线程数/(1-阻塞系数)。  
![在这里插入图片描述][324013a192744744a2b1902d84223369.png]

> IO密集型，即该任务需要⼤量的IO，即⼤量的阻塞。  
> 在单线程上运⾏IO密集型的任务会导致浪费⼤量的CPU运算能⼒浪费在等待。  
> 所以在IO密集型任务中使⽤多线程可以⼤⼤的加速程序运⾏，及时在单核CPU上，这种加速主要就是利⽤了被浪费掉的阻塞时间。  
> IO密集型时，⼤部分线程都阻塞，故需要多配置线程数：  
> **参考公式：** CPU核数 / 1 - 阻塞系数 阻塞系数在 0.8~0.9 之间  
> ⽐如 8 核 CPU：8/1 - 0.9 = 80个线程数

# 八 线程池配置工具类 #

我们在实际项目当中会将线程池配置交给Spring容器管理，使用时直接从容器中取即可。具体配置工具类参考下面连接  
[线程池配置工具类][Link 1]

# 九线程池都有哪些状态？ #

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

# 十 扩展链接 #

[Java中线程池的创建与使用][Java]  
[execute和submit的区别][execute_submit]

[da10551488dd46f28e6ab4808bf94e0f.png]: https://img-blog.csdnimg.cn/da10551488dd46f28e6ab4808bf94e0f.png
[4f2901c85cd94949b54c1349a08030be.png]: https://img-blog.csdnimg.cn/4f2901c85cd94949b54c1349a08030be.png
[c5c8a26beb24481e81eed1e16e4357cc.png]: https://img-blog.csdnimg.cn/c5c8a26beb24481e81eed1e16e4357cc.png
[cc157d139a864acc850b1c592d07da64.png]: https://img-blog.csdnimg.cn/cc157d139a864acc850b1c592d07da64.png
[571e711d8c5b4b54a47ec84ebe3dddae.png]: https://img-blog.csdnimg.cn/571e711d8c5b4b54a47ec84ebe3dddae.png
[9e292378bb8748f2a29be747671cedc7.png]: https://img-blog.csdnimg.cn/9e292378bb8748f2a29be747671cedc7.png
[5c96e0fe492344bc8f20804db71af7cb.png]: https://img-blog.csdnimg.cn/5c96e0fe492344bc8f20804db71af7cb.png
[5712bc114d1f498bba866aa9c71c947f.png]: https://img-blog.csdnimg.cn/5712bc114d1f498bba866aa9c71c947f.png
[9afea846b5d1475d86db077f557fa854.png]: https://img-blog.csdnimg.cn/9afea846b5d1475d86db077f557fa854.png
[eacca83213b5426ab8a522f774272663.png]: https://img-blog.csdnimg.cn/eacca83213b5426ab8a522f774272663.png
[59d6bc332889464c85f8c558a61b24e1.png]: https://img-blog.csdnimg.cn/59d6bc332889464c85f8c558a61b24e1.png
[a8cdce14180742cea6118771a1f07e4a.png]: https://img-blog.csdnimg.cn/a8cdce14180742cea6118771a1f07e4a.png
[3a3274430d59471dac7b6f96828a4773.png]: https://img-blog.csdnimg.cn/3a3274430d59471dac7b6f96828a4773.png
[9240017fd92847f890ad1c00d234d501.png]: https://img-blog.csdnimg.cn/9240017fd92847f890ad1c00d234d501.png
[996164f812384c798e0a50d317a0080f.png]: https://img-blog.csdnimg.cn/996164f812384c798e0a50d317a0080f.png
[6d3542b087734a839d95c61d228f5c2a.png]: https://img-blog.csdnimg.cn/6d3542b087734a839d95c61d228f5c2a.png
[d59e6369d4df4d1bba7b89290b36578d.png]: https://img-blog.csdnimg.cn/d59e6369d4df4d1bba7b89290b36578d.png
[c727730498764cacab6e8b866f7c89ed.png]: https://img-blog.csdnimg.cn/c727730498764cacab6e8b866f7c89ed.png
[b13ffd1feb694d7fbfaa66e92eb79549.png]: https://img-blog.csdnimg.cn/b13ffd1feb694d7fbfaa66e92eb79549.png
[b6e6445f851d442e9f280e9300f16715.png]: https://img-blog.csdnimg.cn/b6e6445f851d442e9f280e9300f16715.png
[32e1afc360234b9da33c75170825c305.png]: https://img-blog.csdnimg.cn/32e1afc360234b9da33c75170825c305.png
[324013a192744744a2b1902d84223369.png]: https://img-blog.csdnimg.cn/324013a192744744a2b1902d84223369.png
[Link 1]: https://blog.csdn.net/weixin_43811057/article/details/129580537?spm=1001.2014.3001.5501
[Java]: https://blog.csdn.net/qq_19891197/article/details/127424200
[execute_submit]: https://blog.csdn.net/weixin_48321825/article/details/121406637