多线程 - 线程池

线程池

相关的背景知识

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

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

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

为什么这两个"动作"比创建/销毁更高效的?

创建线程/销毁线程,涉及到用户态 和内核态 之间的切换,它的创建是交由操作系统内核完成的,也就是在内核态完成的.

从"池"获取/还给"池",是用户代码就能实现的(纯粹的用户态操作),不必交给内核操作.

一个操作系统 = 内核＋配套的应用程序

内核 => 操作系统最核心的功能模块集合

配套的应用程序 => 硬件管理,各种驱动,进程管理,内存管理,文件系统...

内核需要给上层应用程序提供支持

例子: println("hello") => 应用程序调用系统内核,告诉内核,我要进行一个打印字符串操作,内核再通过驱动程序,操作显示器,完成上述功能

对"用户态"和"内核态"的理解:

标准库中的线程池

在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 也是同理)
         * */

    }
}

工厂模式

这个操作.使用某个类的某个静态方法,直接构造出一个对象来(相当于是把 new操作,给隐藏到这样的方法后面了)

像这样的方法,就称为"工厂方法",提供这个工厂方法的类,也就称为"工厂类",此处这个代码就使用了"工厂模式"这种设计模式

"工厂模式": 一句话表示,使用普通的方法,来代替构造方法,创建对象.

"工厂模式",是用来填构造方法的坑的 ~~ 唉,无奈之举!!!

例子: 假设现在有个类,来表示平面上的一个点,第一种构造方法使用笛卡尔坐标系提供的坐标,来构造点,第二种构造方法使用极坐标系提供的坐标,来构造点,

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

重载(overload)和重写(override)的区别

重载(overload): 这两个方法在同一个类里是可以构成重载,分别在父类子类里,也是可能构成重载的.

重写(override): 在 Java中,方法重写是和父类子类相关的(如果是其他语言,重写方法不一定通过父类子类),本质上就是用一个新的方法,代替旧的...就得要求新的方法和旧的方法,名字/参数都得一模一样才行.

为了解决上述的这个问题,就可以使用"工厂模式".

备注:

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

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

变量捕获

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

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

ThreadPoolExecutor类的构造方法详解

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

网上的一些资料的答案: 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核心数指的就是逻辑核心.

线程池的"拒绝策略"

实现线程池

~~ 自己写代码实现固定数量线程的线程池

一个线程池,里面至少有两个大的部分

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);
                }
            });
        }
    }
}