（三）并发编程之线程池

喜欢ヅ旅行 2022-01-27 16:57 360阅读 0赞

# 为什么要使用线程池,优势是什么? #

线程池做的工作主要是控制运行的线程的数量,**处理过程中将任务加入队列**,然后在线程创建后启动这些任务,**如果线程超过了最大数量,超出的数量的线程排队等候**,等其他线程执行完毕,再从队列中取出任务来执行.

他的主要特点为:

*  线程复用
 *  控制最大并发数
 *  管理线程.

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

架构实现:  
Java中的线程池是通过Executor框架实现的，该框架中用到了Executor，Executors,ExecutorService，ThreadPoolExecutor这几个类。  
![在这里插入图片描述][2019052712382021.png]  
其中Executors顾名思义，和Collections相似，是一个工具类。  
Executor框架的最顶层实现是ThreadPoolExecutor类，Executors工厂类中提供的newScheduledThreadPool、newFixedThreadPool、newCachedThreadPool方法其实也只是ThreadPoolExecutor的构造函数参数不同而已。通过传入不同的参数，就可以构造出适用于不同应用场景下的线程池，那么它的底层原理是怎样实现的呢，这篇就来介绍下ThreadPoolExecutor线程池的运行过程。

# 线程池四种创建方式 #

Java通过Executors（jdk1.5并发包）提供四种线程池，分别为：

*  newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
 *  newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
 *  newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
 *  newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

重点看其中三个：

1.  **Executors.newFixedThreadPool(int)**  
    ![在这里插入图片描述][20190527125454759.png]  
    主要特点如下:  
    1.创建一个**定长线程池**,可控制线程的最大并发数,超出的线程会在队列中等待.  
    2.newFixedThreadPool创建的线程池corePoolSize和MaxmumPoolSize是 相等的,它使用的是 **LinkedBlockingQueue**，其中阻塞队列长度最大值为**Integer.MAX\_VALUE**  
    ![在这里插入图片描述][20190527152125530.png]
2.  **Executors.newSingleThreadExecutor()**  
    主要特点如下:  
    ![在这里插入图片描述][20190527131021221.png]  
    1.创建一个**单线程化的线程池**,它只会用唯一的工作线程来执行任务,保证所有任务都按照指定顺序执行.  
    2.newSingleThreadExecutor将corePoolSize和MaxmumPoolSize都设置为1,它使用的的**LinkedBlockingQueue**
3.  **Executors.newCachedThreadPool()**  
    主要特点如下:  
    1.创建一个**可缓存线程池**,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则创建新线程.  
    2.newCachedThreadPool将corePoolSize设置为0，MaximumPoolSize设置为**Integer.MAX\_VALUE**,它使用 的是**SynchronousQUeue**,也就是说来了任务就创建线程运行,如果线程空闲超过60秒,就销毁线程

从上面可以看出，其实三个线程池都调用了ThreadPoolExecutor来进行创建线程池，那么ThreadPoolExecutor底层究竟是什么？

# ThreadPoolExecutor的七个参数 #

点击上面调用的**ThreadPoolExecutor**的构造函数，可以跳到ThreaPoolExecutor.java 类  
![在这里插入图片描述][20190527131654742.png]  
直接点开this，查看七个参数的版本  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTUxNDg1_size_16_color_FFFFFF_t_70]  
从图中可以看出，ThreadPoolExecutor有7个参数，那么这七个参数到底代表什么意思呢？

1.  **corePoolSize:** 线程池中的常驻核心线程数。  
    （1）在创建了线程池后,当有请求任务来之后,就会安排池中的线程去执行请求任务,近似理解为今日当值线程  
    （2）当线程池中的线程数目达到corePoolSize后,就会把到达的任务放入到**缓存队列**当中.
2.  **maximumPoolSize:** 线程池能够容纳同时执行的**最大线程数**,此值大于等于1
3.  **keepAliveTime:** 多余的空闲线程存活时间,当空间时间达到**keepAliveTime** 值时,多余的线程会被销毁直到只剩下**corePoolSize** 个线程为止。  
    （1）默认情况下:只有当线程池中的线程数大于**corePoolSize**时**keepAliveTime**才会起作用,直到线程中的线程数不大于 **corepoolSIze**。
4.  unit:keepAliveTime的单位。
5.  workQueue:任务队列,被提交但尚未被执行的任务。
6.  threadFactory:表示生成线程池中工作线程的线程工厂,用户创建新线程,一般用默认即可。
7.  handler:拒绝策略,表示当线程队列满了并且工作线程大于等于线程池的最大显示 数(maxnumPoolSize)时如何来拒绝。

# 线程池底层的工作原理 #

![在这里插入图片描述][20190527133006677.png]  
以下重要!!!  
![在这里插入图片描述][20190527133315662.png]

# 线程池的拒绝策略 #

**等待队列** 也已经排满了，再也塞不下新的任务了，同时，**线程池的maximumPoolSize** 也到达了,无法接续为新任务服务  
这时我们需要拒绝策略机制合理的处理这个问题。  
JDK内置的拒绝策略有四个，分别是

1.  **AbortPolicy(默认)**:直接抛出RejectedException异常阻止系统正常运行。
2.  CallerRunPolicy:"调用者运行"一种调节机制,该策略既不会抛弃任务,也不会抛出异常,而是该任务被线程池拒绝，由调用execute方法的线程执行该任务。
3.  DiscardOldestPolicy:抛弃队列中等待最久的任务,然后把当前任务加入队列中尝试再次提交。
4.  **DiscardPolicy**:直接丢弃任务,不予任何处理也不抛出异常.如果允许任务丢失,这是最好的拒绝策略。  
    ![在这里插入图片描述][20190527145750599.png]  
    ![在这里插入图片描述][20190527150635325.png]  
    以上内置策略均实现了**RejectExecutionHandler** 接口

# 线程池的使用和生产上合理设置参数 #

*  线程池用哪个？  
    上面了解到，Executors提供了一些创建线程池方法，单一的/固定数的/可变你的三种创建线程池的方法,用哪个呢？答案是一个都不用,我们生产上只能使用自定义的。
 *  Executors中JDK给你提供了为什么不用?  
    javaExecutorsThreadPoolExecutorExecutors

1.  FixedThreadPoolSingleThreadPool:Integer.MAX\_VALUEOOM
2.  CachedThreadPoolScheduledThreadPool:Integer.MAX\_VALUEOOM  
    ![在这里插入图片描述][20190527152306579.png]

*  线程池是如何使用的？

public class MyThreadPoolDemo { 
        public static void main(String[] args) { 
            ExecutorService threadPool = new ThreadPoolExecutor(
                    2,
                    5,
                    1L,
                    TimeUnit.SECONDS,
                    new LinkedBlockingDeque<Runnable>(3),
                    Executors.defaultThreadFactory(),
                    //默认抛出异常
                    //new ThreadPoolExecutor.AbortPolicy()
                    //回退调用者
                    //new ThreadPoolExecutor.CallerRunsPolicy()
                    //处理不来的不处理
                    //new ThreadPoolExecutor.DiscardOldestPolicy()
                    new ThreadPoolExecutor.DiscardPolicy()
            );
            //模拟10个用户来办理业务 没有用户就是来自外部的请求线程.
            try { 
                for (int i = 1; i <= 10; i++) { 
                    threadPool.execute(() -> { 
                        System.out.println(Thread.currentThread().getName() + "\t 办理业务");
                    });
                }
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                threadPool.shutdown();
            }
            //threadPoolInit();
        }
    
        private static void threadPoolInit() { 
            /** * 一池5个处理线程 */
            //ExecutorService threadPool= Executors.newFixedThreadPool(5);
            /** * 一池一线程 */
            //ExecutorService threadPool= Executors.newSingleThreadExecutor();
            /** * 一池N线程 */
            ExecutorService threadPool = Executors.newCachedThreadPool();
            //模拟10个用户来办理业务 没有用户就是来自外部的请求线程.
            try { 
                for (int i = 1; i <= 20; i++) { 
                    threadPool.execute(() -> { 
                        System.out.println(Thread.currentThread().getName() + "\t 办理业务");
                    });
                    try { 
                        TimeUnit.MICROSECONDS.sleep(200);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                threadPool.shutdown();
            }
        }
    }

# 如何合理配置线程池？ #

*  **CPU密集型**

System.out.println(Runtime.getRuntime().availableProcessors());查看CPU核数

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

*  **IO密集型**  
    ![在这里插入图片描述][20190527161251401.png]![在这里插入图片描述][20190527161319306.png]

[2019052712382021.png]: /images/20220127/6cccf6e12fec4371877c3054915bd280.png
[20190527125454759.png]: /images/20220127/02800fac4fff4aa192ba4a8029d5d6c9.png
[20190527152125530.png]: /images/20220127/2ddfe87c192e49d5b3eaa3222d753577.png
[20190527131021221.png]: /images/20220127/f1bdb7bdc62a443099edb8a3d102ce0a.png
[20190527131654742.png]: /images/20220127/dd2ca0d2cf6c41488c4b30826edbd0b4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTUxNDg1_size_16_color_FFFFFF_t_70]: /images/20220127/a9d12c3f44f84d0c913bd409904f0056.png
[20190527133006677.png]: /images/20220127/b2c1bf330e794bc886c3426e6450be19.png
[20190527133315662.png]: /images/20220127/d3ff8819eb7645eaa7ce8c8f5c09ed4e.png
[20190527145750599.png]: /images/20220127/e3f3ea0774bb44479311802d095a4c60.png
[20190527150635325.png]: /images/20220127/4645587d50b64e1a83d031cb99b27669.png
[20190527152306579.png]: /images/20220127/f2f32a1f665d43bfb9e886ab1b7595df.png
[20190527161116484.png]: /images/20220127/51bcb613540341fc97f22022f68c6ab8.png
[20190527161251401.png]: https://img-blog.csdnimg.cn/20190527161251401.png
[20190527161319306.png]: /images/20220127/eadc0cf4f5ef42c5a941708a596ce293.png