JUC高级多线程_08：线程池的具体介绍与使用

朱雀 2023-10-05 21:43 30阅读 0赞

> **我是 ABin-阿斌：写一生代码，创一世佳话，筑一揽芳华。 如果小伙伴们觉得我的文章有点 feel ，那就点个赞再走哦。**  
> ![在这里插入图片描述][01244a35a05f9070bf77418374331efc.png_pic_center]

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

*  1 . 简介
 *   *   *  1. 线程池的特点：
         *  2. 线程池的优点：
 *  2 . 使用
 *   *   *  1. 架构
         *  2. 线程池的三大方法：
 *  3 . 底层源码
 *  4 . threadPoolExecutor 7 个重要参数
 *   *   *  1. int corePoolSize：（核心线程池大小）
         *  2. int maximumPoolSize：（最大核心线程池大小）
         *  3. long keepAliveTime：（超时了没有人调用就会释放）
         *  4. TimeUnit unit：（超时单位）
         *  5. BlockingQueue workQueue：（阻塞队列）
         *  6. threadFactory threadFactory：（线程工厂：创建线程的，一般 不用动）
         *  7. RejectedExecutionHandler handler：（拒绝策略）
 *  5 . 底层原理
 *  6 . 线程池的选择
 *  7 . 自定义线程池
 *   *   *  1. 代码示例
         *  2. 改变任务的数量
         *  3. 最大线程数的设置规则
 *  8 .拒绝策略(4种)
 *   *   *  1. 简介
         *  2. 分类（4 种）

## 1 . 简介 ##

#### 1. 线程池的特点： ####

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

#### 2. 线程池的优点： ####

*  **降低资源消耗：** 通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
 *  **提高响应速度：** 当任务到达时，任务可以不需要等待线程创建就能立即执行。
 *  **提高线程的可管理性：** 线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

## 2 . 使用 ##

#### 1. 架构 ####

*  **Java** 中的线程池是通过 **Executor** 框架实现的，该框架中用到了**Executor**，**Executors**，**ExecutorService**，**ThreadPoolExecutor** 这几个类，主要使用 **ExecutorService** 接口  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ0OTgzOA_size_16_color_FFFFFF_t_70_pic_center][]

#### 2. 线程池的三大方法： ####

*  **Executors.newFixedThreadPool(int)**
    
     *  是用于执行长期任务性能好，有固定的线程数，创建一个线程池，一池有N个固定的线程
 *  **Executors.newSingleThreadExecutor()**
    
     *  一个任务一个任务的执行，一池一线程
 *  **Executors.newCachedThreadPool()**
    
     *  执行很多短期异步任务，线程池根据需要创建新线程，但在先前构建的线程可用时将重用它们。可扩容，遇强则强

public class JUC10_ThreadPool {
        
        public static void main(String[] args) {
        
            // 1. 一 个线程池受理 五 个线程
    //        ExecutorService threadpool = Executors.newFixedThreadPool(5);
            // 2. 一 个线程池受理 一 个线程
    //        ExecutorService threadpool = Executors.newSingleThreadExecutor();
            // 3. 一 个线程池受理 N 个线程,可扩容
            ExecutorService threadpool = Executors.newCachedThreadPool();
    
            try {
        
                //模拟有 10 个顾客来办理业务，但只有 5 个办理窗口
                for (int i = 1; i <= 10; i++) {
        
                    threadpool.execute(()->{
        
                        System.out.println("当前"+ Thread.currentThread().getName()+"办理业务");
                    });
    
    
                    //模拟办理所需时间
    //                try {
        
    //                    TimeUnit.MILLISECONDS.sleep(100);
    //                } catch (InterruptedException e) {
        
    //                    e.printStackTrace();
    //                }
                }
    
            }catch (Exception e){
        
                e.printStackTrace();
            }finally {
        
                threadpool.shutdown();
            }
        }
    }

## 3 . 底层源码 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ0OTgzOA_size_16_color_FFFFFF_t_70_pic_center 1][]

*  由图可知上述三个 API 底层调用的都是同一个方法 —— **threadPoolExecutor**
 *  **第五个参数表示一个阻塞队列：**
    
     *  **LinkedBlockingQueue：** 由链表结构组成的有界（但大小默认值为 **integer.MAX\_VALUE**）阻塞队列。
     *  **SynchronousQueue：** 不存储元素的阻塞队列，也即单个元素的队列。（生产一个，消费一个）

## 4 . threadPoolExecutor 7 个重要参数 ##

![20200819151746771.jpg_pic_center][]

#### 1. int corePoolSize：（核心线程池大小） ####

*  线程池中的常驻核心线程数，最少存在的线程数

#### 2. int maximumPoolSize：（最大核心线程池大小） ####

*  线程池中能够容纳同时执行的最大线程数，此值必须大于等于1

#### 3. long keepAliveTime：（超时了没有人调用就会释放） ####

*  多余的空闲线程的存活时间
 *  当前池中线程数量超过 **corePoolSize** 时，且当空闲时间达到 **keepAliveTime** 时，多余线程会被销毁直到只剩下 **corePoolSize** 个线程为止

#### 4. TimeUnit unit：（超时单位） ####

*  **keepAliveTime** 的单位 —— 秒 / 毫秒 / 微秒

#### 5. BlockingQueue workQueue：（阻塞队列） ####

*  任务队列，被提交但尚未被执行的任务

#### 6. threadFactory threadFactory：（线程工厂：创建线程的，一般 不用动） ####

*  表示生成线程池中工作线程的线程工厂，用于创建线程，**一般默认的即可**

#### 7. RejectedExecutionHandler handler：（拒绝策略） ####

*  拒绝策略，表示当队列满了，并且工作线程大于等于线程池的最大线程数（**maximumPoolSize**）时如何来拒绝  
    请求执行的 **runnable** 的策略

## 5 . 底层原理 ##

*  在创建了线程池后，开始等待请求。
 *  当调用 **execute()** 方法添加一个请求任务时，线程池会做出如下判断：
    
     *  如果正在运行的线程数量小于 **corePoolSize**，那么马上创建线程运行这个任务；
     *  如果正在运行的线程数量大于或等于 **corePoolSize**，那么将这个任务**放入 workQueue队列**；
     *  如果这个时候 **workQueue队列** 满了且正在运行的线程数量还小于 **maximumPoolSize**，那么还是要创建非核心线程立刻运行 **workQueue队列** 中的任务；
     *  如果 **workQueue队列** 满了且正在运行的线程数量大于或等于 **maximumPoolSize**，那么线程池会 **启动饱和拒绝策略来执行**。
 *  当一个线程完成任务时，它会从 **workQueue队列** 中取下一个任务来执行。
 *  当一个线程无事可做超过一定的时间（**keepAliveTime**）时，**线程会判断：**
    
     *  如果当前运行的线程数大于 **corePoolSize**，那么这个线程就被停掉。
     *  所以线程池的所它最终会收缩到 **corePoolSize** 的大小。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ0OTgzOA_size_16_color_FFFFFF_t_70_pic_center 2][]

## 6 . 线程池的选择 ##

*  在工作中单一的、固定数的、可变的，三种创建线程池的方法哪个用的多？及为什么？
 *  答 ： 一个都不用
 *  我们可以看看 **《阿里巴巴手册》** 给我们的建议：  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ0OTgzOA_size_16_color_FFFFFF_t_70_pic_center 3][]

## 7 . 自定义线程池 ##

#### 1. 代码示例 ####

public static void main(String[] args) {
        
            ExecutorService threadpool = new ThreadPoolExecutor(2,5, 2L,TimeUnit.SECONDS,
                                                                new LinkedBlockingQueue<>(3),
                                                                Executors.defaultThreadFactory(),
                                                                new ThreadPoolExecutor.AbortPolicy());
    
            try {
        
            	// 改变任务数，观察输出结果
                //模拟有 N 个顾客来办理业务
                for (int i = 1; i <= 5; i++) {
        
                    threadpool.execute(()->{
        
                        System.out.println("当前\t"+ Thread.currentThread().getName()+"\t办理业务");
                    });
                }
    
            }catch (Exception e){
        
                e.printStackTrace();
            }finally {
        
                threadpool.shutdown();
            }
        }

*  任务队列（**workQueue**）的参数如果不写就默认为 **Integer.MAX\_VALUE**，所以需要写上  
    ![20200820140031377.jpg_pic_center][]
 *  线程工厂使用默认的，模仿源码
    
    ![20200820140041828.jpg_pic_center][]
 *  拒绝策略也暂时使用和默认的，下文具体阐述

#### 2. 改变任务的数量 ####

*  **情况一：5 个任务**
    
     *  不会报错，正常执行，两个线程处理完成
 *  **情况二：8 个任务**
    
     *  不会报错，正常执行，五个线程处理完成
 *  **情况三：9 个任务**
    
     *  会报错，会报 **RejectedExecutionException**
 *  **总结：**
    
     *  线程池的**最多可以容纳数** =【最大线程数（**maximumPoolSize**） + 任务队列（**workQueue**）可容纳数】

#### 3. 最大线程数的设置规则 ####

*  如果是 CPU 密集型（CPU 用的最多）：maximumPoolSize（最大线程数） = CPU核数 + 1
 *  注意：在实际开发当中写死参数的方法不可取，原因：每个人的电脑核数不一样。
 *  **具体优化方案如下代码展示：** 采取自动获取 CPU 核数

// 获取电脑的 CPU 核数
    int CPU = Runtime.getRuntime().availableProcessors();
    int maximumPoolSize = CPU + 1;

*  **如果是 IO 密集型 ：** **maximumPoolSize**（最大线程数）= CPU核数 / 阻塞系数

## 8 .拒绝策略(4种) ##

#### 1. 简介 ####

*  等待队列已经排满了，再也塞不下新任务了，同时，线程池中的 **max** 线程也达到了，无法继续为新任务服务
 *  也即 **最多可以容纳数** 达到最大
 *  这个是时候我们就需要拒绝策略机制合理的处理这个问题

#### 2. 分类（4 种） ####

*  **ThreadPoolExecutor.AbortPolicy()**
    
     *  **解释 ：** 当线程池中任务数量超出 **最多可容纳数** 时，会直接**抛出** **RejectedExecutionException** 异常 **阻止**系统正常运行
 *  **Executor** 默认的策略
    
    ![20200820142834798.jpg_pic_center][]
    
    ![20200820142948325.jpg_pic_center][]
 *  **ThreadPoolExecutor.CallerRunsPolicy**
    
     *  **调用者运行** 一种调节机制，该策略既**不会抛弃任务**，也**不会抛出异常**，而是将某些任务**回退到调用者**，从而降低新任务的流量。
 *  **举例 ：**
    
     *  **营业厅A** 人多，告诉顾客去 **营业厅B** 办理 ，可是顾客来到 **营业厅B** 时， **营业厅B** 人更多，便告诉顾客再去 **营业厅A** 看看。 —— 即不放弃任何一个顾客 ； **营业厅B** 把顾客 ***回退*** 给 **营业厅A**
 *  **ThreadPoolExecutor.DiscardOldestPolicy**
    
     *  **抛弃**队列中**等待最久**的任务，然后把当前任务加人队列中尝试再次提交当前任务。
 *  **ThreadPoolExecutor.DiscardPolicy**
    
     *  该策略默默地**丢弃无法处理的任务**，不予任何处理也**不抛出异常**。如果允许任务丢失，这是最好的一种策略。

[01244a35a05f9070bf77418374331efc.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/01244a35a05f9070bf77418374331efc.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ0OTgzOA_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200819142205477.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ0OTgzOA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ0OTgzOA_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200819145412641.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ0OTgzOA==,size_16,color_FFFFFF,t_70#pic_center
[20200819151746771.jpg_pic_center]: https://img-blog.csdnimg.cn/20200819151746771.jpg#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ0OTgzOA_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/202008191601438.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ0OTgzOA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ0OTgzOA_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20200820133318491.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ0OTgzOA==,size_16,color_FFFFFF,t_70#pic_center
[20200820140031377.jpg_pic_center]: https://img-blog.csdnimg.cn/20200820140031377.jpg#pic_center
[20200820140041828.jpg_pic_center]: https://img-blog.csdnimg.cn/20200820140041828.jpg#pic_center
[20200820142834798.jpg_pic_center]: https://img-blog.csdnimg.cn/20200820142834798.jpg#pic_center
[20200820142948325.jpg_pic_center]: https://img-blog.csdnimg.cn/20200820142948325.jpg#pic_center