多线程 - 线程池

怼烎@ 2023-10-16 18:36 19阅读 0赞

![v2-d063475533f419d1183152a0252a44ee\_1440w][v2-d063475533f419d1183152a0252a44ee_1440w]

## **线程池** ##

### **相关的背景知识** ###

线程池存在的意义: 使用进程来实现并发编程,效率太低了,任务太重了,为了提高效率,此时就引入了线程,线程也叫做“轻量级进程”,创建线程比创建进程更高效;销毁线程比销毁进程更高效;调度线程比调度进程更高效…此时,使用多线程就可以在很多时候代替进程来实现并发编程了.

俗话说,有对比就有伤害,线程和进程比,确实是有优势的,不过,随着并发程度的提高,我们对于性能要求标准的提高,就发现,线程的创建也没有那么轻量…当需要频繁创建销毁线程的时候,就发现,好像开销还是挺大的…想要进一步的再提高这里的效率,程序猿们就想出了两种办法:

1.  弄一个“轻量级线程” => 协程/纤程(问题是这个东西目前还没有被加入到java标准库,无法使用)  
    注: GO语言就内置了协程,因此使用Go开发并发编程程序是有一定优势的,这也是GO语言这么火的原因之一.
    
     *  go属于语法层面支持协程
     *  Java是第三方库层面上支持协程C+＋是标准库层面上支持
     *  Python是语法层面支持…
2.  使用线程池,来降低创建/销毁线程池的开销.  
    线程池比如: 字符串常量池,数据库连接池  
    事先把需要使用的线程创建好,放到"池”中.后面需要使用的时候,直接从池里获取.  
    如果用完了,也还给池,这两个“动作”比创建/销毁更高效的.

#### **为什么这两个“动作”比创建/销毁更高效的?** ####

创建线程/销毁线程,涉及到**用户态**和**内核态**之间的切换,它的创建是交由操作系统内核完成的,也就是在内核态完成的.  
从“池”获取/还给“池”,是用户代码就能实现的(纯粹的用户态操作),不必交给内核操作.

> 一个操作系统 = 内核＋配套的应用程序  
> 内核 => 操作系统最核心的功能模块集合  
> 配套的应用程序 => 硬件管理,各种驱动,进程管理,内存管理,文件系统…  
> 内核需要给上层应用程序提供支持  
> 例子: `println("hello")` => 应用程序调用系统内核,告诉内核,我要进行一个打印字符串操作,内核再通过驱动程序,操作显示器,完成上述功能

#### **对“用户态”和“内核态”的理解:** ####

![image-20231009144310707][]

### **标准库中的线程池** ###

在Java标准库中,给我们提供了现成的线程池,可以直接进行使用.

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * Created with IntelliJ IDEA.
     * Description:
     * User: fly(逐梦者)
     * Date: 2023-10-08
     * Time: 20:53
     */
    public class ThreadDemo26 {
        
        public static void main(String[] args) {
        
            // 创建了一个线程池,池子里现成数目固定是 10 个.
            ExecutorService pool = Executors.newFixedThreadPool(10);
            // 这个操作,使用Executors类的某个静态方法,直接构造出一个对象来 ~~ (相当于是把 new 操作,给隐藏到这样的方法后面了)
            // 像这样的方法,就称为"工厂方法"
            // 提供这个工厂方法的类,也就称为"工厂类"
            // 此处这个代码就使用了“工厂模式"这种设计模式
    
            for (int i = 0; i < 1000; i++) {
        
                int n = i; // 变量捕获
                pool.submit(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println("hello" + n);
                    }
                });
            }
            // 线程池提供的 submit 方法,可以给线程池提交若干个任务
            /*
             * 运行程序之后发现, main 线程结束了,但是整个进程没结束
             * 线程池中的线程都是 前台线程 , 此时会组织进程结束.(前面定时器 Timer 也是同理)
             * */
    
        }
    }

#### **工厂模式** ####

![image-20231009145956193][]

这个操作.使用某个类的某个静态方法,直接构造出一个对象来(相当于是把 new操作,给隐藏到这样的方法后面了)  
像这样的方法,就称为"工厂方法",提供这个工厂方法的类,也就称为“工厂类",此处这个代码就使用了“工厂模式"这种设计模式  
“工厂模式": 一句话表示,使用普通的方法,来代替构造方法,创建对象.  
“工厂模式”,是用来填构造方法的坑的 ~~ 唉,无奈之举!!!  
例子: 假设现在有个类,来表示平面上的一个点,第一种构造方法使用笛卡尔坐标系提供的坐标,来构造点,第二种构造方法使用极坐标系提供的坐标,来构造点,  
![image-20231009164222226][]

正常来说,多个构造方法是通过"重载”的方式来提供的.重载的要求是,方法名相同,参数的个数或者类型不相同.所以,上述的两个构造方法是无法构成重载的,代码是会编译报错的.

> 重载(overload)和重写(override)的区别  
> 重载(overload): 这两个方法在同一个类里是可以构成重载,分别在父类子类里,也是可能构成重载的.  
> 重写(override): 在 Java中,方法重写是和父类子类相关的(如果是其他语言,重写方法不一定通过父类子类),本质上就是用一个新的方法,代替旧的…就得要求新的方法和旧的方法,名字/参数都得一模一样才行.

为了解决上述的这个问题,就可以使用“工厂模式”.  
![image-20231009170506362][]

备注:

1.  `ExecutorService pool = Executors.newCachedThreadPool();`创建的线程池,不会设定固定值,按需创建,用完之后也不会立即销毁,留着以后备用.`Executors.newCachedThreadPool()`和`Executors.newFixedThreadPool(10)`和相关的工厂方法,其实都是基于`ThreadPoolExecutor`的封装.
2.  其实很多设计模式,和“工厂模式”一样,也都没什么难度.只是名字听起来高大上,其实并不是什么高深莫测的东西.很多时候,设计模式,是在规避编程语言语法上的坑.  
    不同的语言,语法规则不一样.因此在不同的语言上,能够使用的设计模式,可能会不同.有的设计模式,已经被融合在语言的语法内部了…日常见到的设计模式，主要是基于C++/Java/C\#这样语言来展开的,这里所说的设计模式不一定适合其他语言,工厂模式,就对于Python来说没什么价值 ~~ Python构造方法,不像C++ / Java的这么坑,它可以直接在构造方法中通过其他手段来做出不同版本的区分…

![image-20231009173545839][]

注: 官方文档,非常重要,学习过程中,要经常去翻这个文档!!

#### **变量捕获** ####

![image-20231010004105221][]

在Java 中,对于变量捕获,做了一些额外的要求.在JDK 1.8之前,要求变量捕获,只能捕获 final修饰的变量.后来发现,这么做太麻烦了.在JDK1.8开始,放松了一点标准,要求不一定非得带 final关键字,只要代码中没有修改这个变量,也可以捕获.

![image-20231010005710959][]

注: Java 的变量捕获要有不可修改的要求,但是 C++, JS 也有类似的变量捕获的语法,但是没有上述限制.

![image-20231010012528922][]

#### **ThreadPoolExecutor类的构造方法详解** ####

![image-20231010095225482][]

### **实际开发的时候,线程池的线程数,设定成多少合适呢?** ###

网上的一些资料的答案: N(CPU的核数), N + 1,1.5N, 2N ……不过以上这些答案都不对. 线程池的线程数的设定多少合适是没有具体的数字的,因为不同的程序特定不同,此时要设置的线程数也是不同的.  
考虑两个极端情况:  
1.CPU 密集型,每个线程要执行的任务都是狂转CPU(进行一些列算术运算),此时线程池的线程数,最多不应该超过 CPU 核数.此时如果设置更多的线程数,也起不到作用,CPU密集型任务,要一直占用CPU,过多创建的线程,CPU根本调度不来.  
2.IO 密集型,每个线程做的工作就是等待 IO(读写硬盘,读写网盘,等待用户输入……),此时,线程是不“吃”CPU的,因为这样的线程处于阻塞状态,不参与CPU调度……这个时候线程池多创建一些线程是可以的,不会再收制于CPU核数了.理论上来说,现在线程数设置无穷大都可以,当然,现实会因为系统的资源不够而失败.

不过,实际开发中并没有程序符合这两种理想模型…真实的程序,往往一部分要吃CPU,一部分要等待IO  
具体这个程序几成工作量是吃CPU的,几成工作量是等待IO,是**不确定**的………  
实际确定线程数量,是试出来的,通过测试/实验的方式(实践是检验真理的唯一标准).

> 小知识: 现在的CPU,是一个物理核心上可以有多个逻辑核心的.  
> 8核16线程 => 8个物理核心,每个物理核心上有两个逻辑核心,每个逻辑核心同一时刻只能处理一个线程  
> 一般情况下,对于我们程序猿来说,谈到CPU核心数指的就是逻辑核心.

### **线程池的“拒绝策略”** ###

![image-20231010111915034][]

### **实现线程池** ###

~~ 自己写代码实现固定数量线程的线程池  
一个线程池,里面至少有两个大的部分  
1.阻塞队列,保存任务  
2.若干个工作线程.

#### 相关代码 ####

import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingQueue;
    
    /**
     * Created with IntelliJ IDEA.
     * Description: 实现简单线程池 ~~ 实现固定数量的线程池
     * User: fly(逐梦者)
     * Date: 2023-10-9
     * Time: 11:55
     */
    class MyThreadPool {
        
    
        // 此处只有任务,就直接使用 Runnable 即可
        private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();
    
        // n 表示线程的数量
        public MyThreadPool(int n) {
        
            // 开始创建线程
            for (int i = 0; i < n; i++) {
        
                Thread t = new Thread(() -> {
        
                    while (true) {
        
                        try {
        
                            Runnable runnable = queue.take();
                            runnable.run();
                        } catch (InterruptedException e) {
        
                            throw new RuntimeException(e);
                        }
                    }
                });
                t.start();
            }
        }
    
        // 注册任务给线程池
        public void submit(Runnable runnable) {
        
            try {
        
                queue.put(runnable);
            } catch (InterruptedException e) {
        
                throw new RuntimeException(e);
            }
        }
    
    }
    
    public class ThreadDemo27 {
        
        public static void main(String[] args) {
        
            MyThreadPool pool = new MyThreadPool(10);
            for (int i = 0; i < 1000; i++) {
        
                int n = i;
                pool.submit(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println("hello " + n);
                    }
                });
            }
        }
    }

[v2-d063475533f419d1183152a0252a44ee_1440w]: https://img-blog.csdnimg.cn/img_convert/de0e9990cd6879a47a81b61d96e3a19e.webp?x-oss-process=image/format,png
[image-20231009144310707]: https://img-blog.csdnimg.cn/img_convert/3655baf8770ac54482f0c05b06c190b4.png
[image-20231009145956193]: https://img-blog.csdnimg.cn/img_convert/13427bf7c427ef77edbee98ff634adb2.png
[image-20231009164222226]: https://img-blog.csdnimg.cn/img_convert/f9cd4df8e2972b82712ba038899ac274.png
[image-20231009170506362]: https://img-blog.csdnimg.cn/img_convert/1a574f637ced620c064a10f8c6f42177.png
[image-20231009173545839]: https://img-blog.csdnimg.cn/img_convert/008b9708f4b389729747af939cc32afb.png
[image-20231010004105221]: https://img-blog.csdnimg.cn/img_convert/4f0e24feeda305467b4c6f2f72114a89.png
[image-20231010005710959]: https://img-blog.csdnimg.cn/img_convert/3d8bd0426a8b4c5a4a89866137ee5536.png
[image-20231010012528922]: https://img-blog.csdnimg.cn/img_convert/7c28f8626ab8c332b0857e5f8f78d21c.png
[image-20231010095225482]: https://img-blog.csdnimg.cn/img_convert/6dec9dbd948dc70f1d9303ca63a89818.png
[image-20231010111915034]: https://img-blog.csdnimg.cn/img_convert/2dbedec9531955e454876c03318b92c6.png