【JUC】九、线程池ThreadPool

绝地灬酷狼 2024-02-18 11:32 20阅读 0赞

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

*  1、线程池
 *  2、分类
 *  3、线程池的使用
 *  4、工作流程
 *  5、拒绝策略
 *  6、线程池的七个参数
 *  7、自定义线程池
 *  8、什么时候考虑使用线程池？

## 1、线程池 ##

线程池和数据库连接池的理念很相似，对于数据库连接池：普通的连接数据库是建立一个JDBC连接，执行完sql之后，就会关闭，即销毁connection对象，再次连接还需要重复上述步骤。当与数据库交互频繁时，这种模式会严重影响程序的性能，因此有了数据库连接池。对应到线程池thread pool，就是线程池里维护着多个线程，等待监督管理者分配执行任务。线程池带来的好处就是：

*  降低资源消耗：降低避免频繁创建和销毁线程的代价
 *  提高响应速度：任务达到时，不用再等待创建线程
 *  线程管理方便：线程过多，调度开销大，用线程池可防止过分调度，且可以做统一的监控、分配、调优

关于线程切换的例子：10 年前单核 CPU 电脑，假的多线程，像**马戏团小丑玩多个球**，CPU 需要来回切换。 现在是多核电脑，多个线程各自跑在独立的 CPU 上，不用频繁切换，效率高。

## 2、分类 ##

Java 中的线程池是通过 Executor 框架实现的，该框架中用到了 Executors（工具类）、ExecutorsExecutorService、ThreadPoolExecutor这几个类  
![在这里插入图片描述][d560fd96454d491396239e7bbf4a961e.png]

线程池有以下几类：

*  一池N线程：Executors.newFixedThreadPool(int num)
 *  一池一线程：Executors.newSingleThreadExecutor()
 *  可扩容池，根据需求创建一定数量的线程，遇强则强：Executors.newCachedThreadPool()

## 3、线程池的使用 ##

*  创建线程池对象
 *  调用execute方法提交任务

public class ThreadPoolDemo {
        
    
        public static void main(String[] args) {
        
            //一池五线程
            ExecutorService threadPool = Executors.newFixedThreadPool(3);
            //一池1线程
            ExecutorService threadPool1 = Executors.newSingleThreadExecutor();
            //一池可扩容线程
            ExecutorService threadPool2 = Executors.newCachedThreadPool();
            //提交10次任务到线程池
            try{
        
                for (int i = 1; i <= 20; i++) {
        
                    //提交任务到另一线程（线程池中的）
                    threadPool2.execute(() -> {
        
                        System.out.println(Thread.currentThread().getName() + "线程正在办理业务");
                    });
                }
            }catch(Exception e){
        
                e.printStackTrace();
            }finally{
        
                threadPool2.shutdown();
            }
    
        }
    }

以可扩容线程池为例：

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

## 4、工作流程 ##

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

如图，此时常驻线程数为2，最大线程数为5，阻塞队列长度为3（黑点），此时来了两个任务1和2 ⇒ 直接常驻线程 ⇒ 那两个任务还执行完，又来了几个任务3、4、5 ⇒ 这时不是直接上最大线程，而是进入阻塞队列 ⇒ 此时又来了三个人6、7、8 ⇒ 发现阻塞队列也满了，那就开启最大线程处理6、7、8的业务 **（注意新开的线程不是去处理阻塞队列了，阻塞队列的3、4、5还是在队列中继续等待）** ⇒ 此时又来了一个任务9 ⇒ 走拒绝策略

注意这几点：

ExecutorService pool = Executors.newSingleThreadExecutor();

*  执行上面这句，并不会创建线程，而是执行pool.execute方法提交任务时才创建
 *  常驻线程用完了，再来任务，不是直接按最大线程数启动新线程，而是阻塞队列
 *  阻塞队列满了以后，按最大线程数启动新线程，且新线程处理的不是阻塞队列里的任务

看下源码，从提交任务的execute方法打断点，进入execute方法：

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

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

## 5、拒绝策略 ##

阻塞队列和最大线程数量都用完后，走拒绝策略，JDK内置的拒绝策略有：

*  **AbortPoligy(默认)**：直接抛出RejectedExecutionExption异常阻止系统正常运行
 *  **CallerRunsPoliy**：既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，谁让你来的，你找谁去
 *  **DiscardOldestPoliy**：抛弃阻塞队列中等待最久的任务，然后把当前任务加入队列中
 *  **DiscardPolicy**：默默地丢弃无法处理的任务，不予任何处理也不抛出异常，如果允许任务丢失，这是最好的一种策略

## 6、线程池的七个参数 ##

查看源码可以发现，不管是三种线程池中的哪种，最后都是`return new ThreadPoolExecutor`，关于ThreadPoolExecutor类：

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

*  int corePoolSize：常驻线程数量
 *  int maximumPoolSize：最大线程数量
 *  long keepAliveTime：线程存活时间，线程多长时间没被使用就关闭
 *  TimeUnit unit：存活时间的单位
 *  BlockingQueue workQueue：常驻线程用完了，再来请求线程，进入阻塞队列
 *  ThreadFactory threadFactory：线程工厂
 *  RejectedExecutionHandler handler：拒绝策略

以银行为例对比：银行大厅一共有10个窗口（最大线程数量），但平时一般只开5个（常驻线程数量），某天办理业务的人很多，5个窗口不够用，其余人来了就先在大厅椅子上坐着等（阻塞队列），结果椅子坐满了，还有人陆续来，于是10个窗口全开，还来很多人，那就只能告诉新来的今天轮不到你办了（拒绝策略）。

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

Executors工具类可以创建三种线程池，但通常自定义线程池是因为，Executors返回的线程池对象有以下两个问题：

*  对于FixedThreadPool和SingleThreadPool，代码底层用的阻塞队列是LinkedBlockingQueue类型的，队列长度为Integer.MAX\_VALUE，可能堆积大量请求，导致OOM
 *  对于CachedThreadPool，其源码中写的最大线程数量为Integer.MAX\_VALUE，创建大量线程，调度难度大且会OOM

public class ThreadPoolDemo2 {
        
    
        public static void main(String[] args) {
        
            ExecutorService threadPool = new ThreadPoolExecutor(
                    2,    //常驻或核心线程数
                    5,    //最大线程数
                    2L,
                    TimeUnit.SECONDS,
                    new ArrayBlockingQueue<>(3),  //阻塞队列
                    Executors.defaultThreadFactory(), 
                    new ThreadPoolExecutor.AbortPolicy()  //拒绝策略
            );
            try {
        
                for (int i = 1; i <= 20; i++) {
        
                    threadPool.execute(() -> {
        
                        System.out.println(Thread.currentThread().getName() + "线程正在办理业务");
                    });
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                threadPool.shutdown();
            }
        }
    }

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

## 8、什么时候考虑使用线程池？ ##

到这儿，线程池的作用、分类、底层代码逻辑、参数与策略的问题基本清晰，那什么时候考虑去使用线程池呢？==> 线程池适合处理耗时任务，可以充分使用目前服务器的硬件资源，加快处理速度。更确切的说是：

*  单个任务处理时间比较短
 *  但需要处理的任务的数量大

此时，如果不使用线程池，随意启动许多线程，容易导致系统因创建大量线程而OOM且过渡调度（过渡切换）。比如工作中遇到一个excel数据转换后批量写入库里，就可拆为一批批的小任务去insert。还有帖子说需要限制并发执行的任务数量时也可以用线程池，这儿我先想到的反而是Semaphore信号灯这个JUC辅助类。

[d560fd96454d491396239e7bbf4a961e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/8e036a2df68e4acebf2be9d980157b2e.png
[03b6ca20895d48ceb350532b27c27b24.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/f18ad2a12d1146cb8eaa6400f1c8882a.png
[e7cc0ad08c134e52bc33f4824598714a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/42be74e1db6b4d9b9e615483db3b2779.png
[844eb7fac53f415eb897fdfb2c00e613.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/f5be596406c64b7a8066dce3bafab9b8.png
[a4e880607ca64468a8d932b0af440d7a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/48d420399ddb4ddea215961d61a2afdf.png
[282fca38dc8a4eab90127b41bab65fe0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/c4e105e2207846e6b47af2c1125f8265.png
[5a229e471dd84cc38fded62c674b7aa8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/f22b4d693afd4614b906a6900b96296d.png