JUC 中的线程池入门（其实没有那么难）

Myth丶恋晨 2023-09-26 10:17 132阅读 0赞

线程池，第一次听到这个的时候，我脑海里浮现的是JDBC的连接池，仔细看完狂神老师的视频后，发现线程池开发的目的其实就是和连接池大同小异。

**优点：线程复用、提高响应速度、控制最大并发数、管理线程**

**线程复用**：降低了资源的消耗，通过重复利用已经创建的线程降低线程创建和消耗所造成的的消耗。

**提高了响应速度**：当任务到达了以后，只要线程池李还用未被利用的线程，任务不需要等待线程创建就能立即执行。

**控制最大并发数**：借助于线程池我们可以控制运行的线程数量。

**管理线程**：因为对系统来说，线程是稀缺资源，如果无限制的创建，那不仅会消耗系统资源，还会降低系统的稳定性，因此，可以使用线程池进行统一分配，调优和监控！

那应该怎样快速入门呢？？  
我认为对于我们初学者而言，一开始的时候我们要学会如何使用它就可以了，然后，如果想提高的话，自己可以慢慢学源码，这是一个逐步提高的过程！

因此，线程池的核心就是：**三大方法、七大参数（重点）、四种拒绝策略（重点）**

\*\*

### 1、三大方法 ###

\*\*（只要简单了解一下这三大方法，因为这三大方法是系统自带的线程池对象拥有的，在开发之中，我们都是自定义线程池对象）  
（1）Executors.newFixedThreadPool(int)  
执行长期任务性能好，创建一个线程池，一池有N个固定的线程，有固定线程数的线程。  
假设 int = 5  
举个例子：加入有10个顾客来银行办理业务，池子中有5个固定的窗口能够办理业务。（在这里规定了窗口的数量）  
（2）Executors.newSingleThreadExecutor()  
有且只有一个固定的线程

举个例子：加入有10个顾客来银行办理业务，池子中有1个固定的窗口能够办理业务。（在这里默认规定了窗口的数量为1）

（3）Executors.newCachedThreadPool();  
执行很多短期异步任务，线程池根据需要创建新线程，但在先构建的线程可用时将重用他们。 可扩容，遇强则强

举个例子：加入有10个顾客来银行办理业务，池子中有N个固定的窗口能够办理业务。（在这里动态的调整窗口的数量）

总结：其实在这里就不贴代码了，因为你只要知道有这个东西存在就可以了，然后能够根据具体的例子知道他是如何使用的即可。

\*\*

### 2、七大参数（重点） ###

\*\*  
**（1）corePollSize(核心线程数)：**  
即我们创建了线程池对象之后，线程池中会默认存在corePollSize个核心线程，当线程的数目达到corePollSize后，那么线程池就会把接下来的任务放到缓存队列中。注意：默认情况下，核心线程会一直存活在线程池中，但是如果ThreadPoolExecutor 的 allowCoreThreadTimeOut 属性设为 true，那么如果线程池一直闲置并超过了 keepAliveTime 所指定的时间，核心线程就会被终止。

**（相当于银行默认开的窗口数）**

**（2）maximumPoolSize（最大线程数）：**  
表示线程中最多能够被创建的线程数量，这个数值必须大于等于1。**（相当于银行最多开的窗口数）**  
可伸缩的线程数 = 最大线程数 - 核心线程数

**（3）keepAliveTime（空闲的线程保留时间）：**  
空闲的线程保留的时间。默认情况下对非核心线程生效，如果闲置时间超过这个时间，非核心线程就会被回收。如果 ThreadPoolExecutor 的 allowCoreThreadTimeOut 设为 true 的时候，核心线程如果超过闲置时长也会被回收。

**（4）TimeUnit（空闲线程的保留时间单位）**

空闲线程的保留时间单位。

**（5）BlockingQueue< Runnable>（阻塞队列）**  
其实在这里选一种阻塞队列的存储模型，根据具体的生产环境合理选择相应的存储模型。

**（6）ThreadFactory（线程工厂）**  
线程工厂，用来创建线程，一般默认即可

**（7）RejectedExecutionHandler（线程池异常处理策略）**

队列已满，而且任务量大于最大线程的异常处理策略。这里不细说，因为接下来会仔细讲一下 这四大拒绝策略，但是不难！

**这些参数所需要注意的知识点：**  
![在这里插入图片描述][b96e711699784efb9a4897df127d0f9a.png]

package com.day20221007;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    public class ThreadPoolDemo {
        
        public static void main(String[] args) {
        
            //自定义线程池
            ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                    //核心线程数
                    2,
                    //最大线程数
                    5,
                    //空闲的线程的保留时间
                    2,
                    //空闲线程保留时间单位
                    TimeUnit.SECONDS,
                    //阻塞队列
                    new LinkedBlockingQueue<>(3),
                    //线程工厂
                    Executors.defaultThreadFactory(),
                    //异常处理策略
                    new ThreadPoolExecutor.AbortPolicy());
            try {
        
                for(int i=1;i<=6;i++){
        
                    final int temp = i;
                    threadPool.execute(()->{
        
                        try {
        
                            System.out.println(Thread.currentThread().getName()+"办理业务");
                            TimeUnit.SECONDS.sleep(10);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
    
                    });
                }
            }catch (Exception e){
        
                e.printStackTrace();
            }finally {
        
                //注意在用完线程池之后一定要关闭！！！！，不然会造成资源浪费！
                threadPool.shutdown();
            }
        }
    }

**2、这里给大家贴一张图，帮助大家加深一下理解：**  
![在这里插入图片描述][461c5de188844f658ea1be0211e965b7.png]  
![在这里插入图片描述][7766d85d12c7452cadbf40bd413cef20.png]  
![在这里插入图片描述][d576bfffc3524735b30051dd4adfdfff.png]  
3、线程池中的工作原理：  
![在这里插入图片描述][02bc2922c18844a691740fcd670ddef8.png]  
当线程池中有任务需要执行时，线程池会判断如果线程数量没有超过核心数量就会新建线程池进行任务执行，如果线程池中的线程数量已经超过核心线程数，这时候任务就会被放入任务队列中排队等待执行；如果任务队列超过最大队列数，并且线程池没有达到最大线程数，就会新建线程来执行任务；如果超过了最大线程数，就会执行拒绝执行策略。

\*\*

### 3、四大拒绝策略： ###

\*\*

**为什么会有拒绝策略呢？**

因为以银行为例，当我们银行的所有服务窗口都在工作，并且银行的待客区也人满为患了，那么这时候如果再有人来办业务，我们就得对他们说sorry了，这也就是所谓的拒绝策略！（当然，在实际中如果我们这样，我们就会被举报了）

**因此达到拒绝策略的条件：达到最大容量。**

**最大容量 = maximumPoolSize（最大线程数） + workQueue （阻塞队列的容量）**

举个例子：  
maximumPoolSize：银行所有的服务窗口数量。  
workQueue ：银行待客区所能容纳的最多客户数量。

因此当达到最大容量的时候，这时候拒绝策略就要大显神通了，其实简单来说，总共有四大拒绝策略：  
![在这里插入图片描述][362dc850ecb44e4492966ccd43652db3.png]

RejectedExecutionHandler rejected = null; 
    rejected = new ThreadPoolExecutor.AbortPolicy();//默认，队列满了丢任务，抛出异常
    rejected = new ThreadPoolExecutor.DiscardPolicy();//队列满了丢任务，不抛出异常【如 果允许任务丢失这是最好的】 
    rejected = new ThreadPoolExecutor.DiscardOldestPolicy();//将最早进入队列的任务 删，之后再尝试加入队列 
    rejected = new ThreadPoolExecutor.CallerRunsPolicy();//如果添加到线程池失败，那么 主线程会自己去执行该任务，回退

根据我们的需要合理选择相应的拒绝策略即可！！

package com.day20221007;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    public class ThreadPoolDemo {
        
        public static void main(String[] args) {
        
            //自定义线程池
            ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                    //核心线程数
                    2,
                    //最大线程数
                    5,
                    //空闲的线程的保留时间
                    2,
                    //空闲线程保留时间单位
                    TimeUnit.SECONDS,
                    //阻塞队列
                    new LinkedBlockingQueue<>(3),
                    //线程工厂
                    Executors.defaultThreadFactory(),
                    //异常处理策略
                    new ThreadPoolExecutor.AbortPolicy());
            try {
        
                //在这里引起拒绝策略的最大容量是： 5+3 = 8
                for(int i=1;i<=9;i++){
        
                    final int temp = i;
                    threadPool.execute(()->{
        
                        try {
        
                            System.out.println(Thread.currentThread().getName()+"办理业务");
                            TimeUnit.SECONDS.sleep(10);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
    
                    });
                }
            }catch (Exception e){
        
                e.printStackTrace();
            }finally {
        
                //注意在用完线程池之后一定要关闭！！！！，不然会造成资源浪费！
                threadPool.shutdown();
    
            }
    
    
    
        }
    }

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

\*\*

### 最后，大家还要注意一定用完之后要关闭线程池啊！！！ ###

\*\*

[b96e711699784efb9a4897df127d0f9a.png]: https://img-blog.csdnimg.cn/b96e711699784efb9a4897df127d0f9a.png
[461c5de188844f658ea1be0211e965b7.png]: https://img-blog.csdnimg.cn/461c5de188844f658ea1be0211e965b7.png
[7766d85d12c7452cadbf40bd413cef20.png]: https://img-blog.csdnimg.cn/7766d85d12c7452cadbf40bd413cef20.png
[d576bfffc3524735b30051dd4adfdfff.png]: https://img-blog.csdnimg.cn/d576bfffc3524735b30051dd4adfdfff.png
[02bc2922c18844a691740fcd670ddef8.png]: https://img-blog.csdnimg.cn/02bc2922c18844a691740fcd670ddef8.png
[362dc850ecb44e4492966ccd43652db3.png]: https://img-blog.csdnimg.cn/362dc850ecb44e4492966ccd43652db3.png
[18903f79a0fe4423998400ac378f7388.png]: https://img-blog.csdnimg.cn/18903f79a0fe4423998400ac378f7388.png