Java多线程案例——线程池

如风暖阳

已于 2022-10-08 15:33:08 修改

阅读量9.5k

点赞数 37

分类专栏： JavaEE初阶文章标签： java

于 2022-05-11 00:18:58 首次发布

本文链接：https://blog.csdn.net/qq_60856948/article/details/124692289

版权

JavaEE初阶专栏收录该内容

26 篇文章 4 订阅

订阅专栏

在这里插入图片描述
⭐️前言⭐️

🍉博客主页： 🍁【如风暖阳】🍁
🍉精品Java专栏【JavaSE】、【Java数据结构】、【备战蓝桥】、【JavaEE初阶】
🍉欢迎点赞 👍 收藏 ⭐留言评论 📝私信必回哟😁

🍉本文由【如风暖阳】原创，首发于 CSDN🙉

🍉博主将持续更新学习记录收获，友友们有任何问题可以在评论区留言

🍉博客中涉及源码及博主日常练习代码均已上传码云(gitee)

📍内容导读📍

Java多线程案例之线程池

Java多线程案例之线程池

🍅1.线程池是什么

1.1 线程池

本来多进程就是解决并发编程的方案，但是进程有点太重量了（创建和销毁开销比较大），因此引入了线程，线程比进程要轻量很多。即便如此，如果在某些场景中需要频繁的创建和销毁线程，线程的创建销毁开销也就无法忽视了。

为了解决这样的问题，我们引入了线程池：

使用线程的时候，不是说用的时候才创建，而是提前创建好，放到一个“池子”里（类似于字符串常量池），当我们需要使用线程的时候，直接从池子里面取一个线程出来，当我们不需要这个线程的时候，就把这个线程还回池子中（此时我们的操作就会比创建销毁线程效率更高）。

为了更好的理解线程池的概念我们引入下边这个例子：

在我们找工作时，面试结束之后会面临两个结果，1是已经通过oc(offer call)，2是没有通过，但是公司不会直接告诉你你没有通过，而是完全不通知（公司会把你放到“人才储备池”里），此时假设A公司要招100人而目前只招够了60个人，剩下的40个名额公司将会从“人才储备池”中直接挑选hc(head count),直接发offer，从而避免了需要再次笔试面试等一系列的流程来招纳新人。

如果是真的创建/销毁线程，就会涉及到用户态和内核态的切换。
如果不是真的创建销毁线程，而是放到池子里，就相当于全在用户态搞定了这个事情。
在用户态操作会比较高效，切换到内核态以后操作就可能很低效。
线程池最大的好处就是减少每次启动、销毁线程的损耗

下边便是用户态和内核态的具体介绍

1.2 用户态与内核态

用户态就是应用程序执行的代码，内核态就是操作系统内核执行的代码，一般认为，用户态和内核态之间的切换，是一个开销比较大的操作。

比如我们去银行办理业务时，需要去复印一份文件，如果我们自己去复印，就能够很快的完成并交给工作人员，但如果让工作人员去完成这个打印文件的工作就会比较耗费时间（工作人员需要完成的工作很多，不能及时调度去完成打印文件工作）。
此时的我们便是用户态，工作人员便是内核态。

🍅2.标准库中的线程池

在Java的标准库中，有下边这两者方式来创建线程池

2.1 ThreadPoolExecutor

在这里插入图片描述

ThreadPoolExecutor的使用是相对复杂的，因为里边有很多的参数，ThreadPoolExecutor的构造方法的参数是什么意思，便是一道经典的面试题：（）中的含义在下边引用中有介绍

corePoolSize ：核心线程数（正式员工的数量）
maximumPoolSize：最大线程数（正式工+临时工）
keepAliveTime：线程保持活动的时间（描述临时工摸鱼可以摸多久）
unit：keepAliveTime的时间单位（ms,s,minute）
workQueue：阻塞队列，组织了线程池要执行的任务
threadFactory：线程的创建方式，通过这个参数，来设定不同的线程的创建方式
RejectedExecutionHandler：拒绝策略，当任务队列满了的时候，又来了新的任务，要根据具体的业务场景来选取具体的拒绝策略

我们可以把线程池想象成一个“公司”，公司里面的每个员工，就相当于是一个线程。
员工分为两类：
1，正式工（corePoolSize）：签了劳动合同的，不能随便辞退
2，临时工：没有签劳动合同，随时可以踢掉
正式员工允许摸鱼（这样的线程即使是空闲，也不会被销毁）
临时工不允许摸鱼（如果临时工线程摸鱼的时间到了一定程度，就会被销毁）
如果我们要解决的任务场景任务量比较稳定，就可以设置corePoolSize和maximumPoolSize尽量接近（临时工就可以少一些）
如果我们要解决的任务场景任务量波动较大，既可以设置corePoolSize和maximumPoolSize相差大一些（临时工就可以多一些）

我们需要主要了解的是拒绝策略，在实际开发中，要根据具体的业务场景来选取具体的拒绝策略：
在这里插入图片描述

以老板给员工分配工作的任务为例，来引出这四种拒绝策略：（员工相当于线程池）
1.老板给员工分配了很多任务，员工即使加班也无法完成工作，导致情绪崩溃，所有的工作都不干了。
2.老板给员工分配了很多任务，员工完不成的老板接手，如果老板也无法完成，就丢弃任务。
3.老板给员工安排了工作1、2、3、4，此时员工搞不定了，就可以先丢弃工作1（最旧的），去干其他的工作。
4.老板给员工安排了工作1、2、3、4，此时员工搞不定了，就可以先丢弃工作4（最新的），去干其他的工作。

1.AbortPolicy:中止策略，线程池会抛出异常并中止执行此任务；
2.CallerRunsPolicy:把任务交给添加此任务的线程来执行；
3.DiscardOldestPolicy:忽略最先加入队列的任务(最老的任务)；
4.DiscardPolicy:忽略此任务(最新加入的任务)。

面试题：
线程池的数目如何确定？或者说设置成几比较合适？

我们并不能给出确定的具体个数，原因有以下两点：
1.主机的CPU配置不确定
2.程序的执行特点不确定

所以只有针对程序进行性能测试，分别给线程池设置成不同的数目，分别记录每种情况，才能最终选一个合适的配置。

2.2 Executors

由于ThreadPoolExecutor使用起来比较复杂，标准库又提供了Executors类，相当于对ThreadPoolExecutor又进行了一层封装，这个类相当于一个“工厂类”，通过这个类提供的一组工厂方法，就可以创建出不同风格的线程池实例了。（工厂模式在2.3中讲解）

Executors 创建线程池的几种方式：

newFixedThreadPool: 创建固定线程数的线程池（完全没有临时工的版本）
newCachedThreadPool: 创建线程数目可变的线程池.（完全没有正式员工，全是临时工）
newSingleThreadExecutor: 创建只包含单个线程的线程池. （只在特定场景下使用）
newScheduledThreadPool: 能够设定延时时间的线程池（插入的任务能够过一会再执行），相当于进阶版的定时器。

代码示例：

public class Demo2 {
    public static void main(String[] args) {
        //用标准库中的线程池，创建出一个线程池中的实例
        ExecutorService pool= Executors.newCachedThreadPool();
        //给这个实例里面加入一些任务
        for (int i = 0; i < 5; i++) {
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello");
                }
            });
        }
    }
}

在这里插入图片描述

2.3 工厂模式

Executors类的几种创建线程池的方式就是工厂模式的体现，工厂模式也是一种设计模式，和单例模式是并列的关系，工厂模式存在的意义，就是弥补构造方法的一些缺陷。

工厂模式主要是为了创建实例，正儿八经的创建实例是通过构造方法，但是构造方法的限制比较多：
1.构造方法的名字，必须是固定的（类名）
2.如果需要多个版本的构造方式，就只能依赖构造方法的重载，但是重载方法又要求方法参数的个数和类型不一致。
比如下边这个例子：

假设我们有个类Point，我们希望通过笛卡尔坐标和极坐标两种方式来构造这个点

class Point {
		public Point(double x,double y){...}       -->笛卡尔坐标
		public Point(double r,double a){...}       -->极坐标
}

但是这俩方法的参数个数和类型都一样，这个时候编译不了，而且构造方法的方法名是固定的，光看方法名并不知道咱们是使用哪种方式构造

为了解决这个问题：
我们就不使用构造方法来构造实例了，而是使用其他的方法来进行构造实例，这样的用来构造实例的方法就被称为“工厂方法”。
工厂方法其实就是普通的方法，这个工厂方法里面会调用对应的构造方法，并进行一些初始化的操作，并返回这个对象的实例。

🍅实现线程池

核心操作为 submit, 将任务加入线程池阻塞队列中，并创建线程
使用一个 BlockingQueue 组织所有的任务
一个线程池可以同时提交N个任务，对应的线程池中有M个线程来负责完成这N个任务，利用生产者消费者模型，把N个任务分配给M个线程

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

class MyThreadPool {
    private BlockingQueue<Runnable> queue=new LinkedBlockingQueue<>();
    
    public void submit(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }
    
    public MyThreadPool(int m) {
        //在构造方法中，创建出M个线程，负责完成工作
        for (int i = 0; i < m; i++) {
            Thread t=new Thread(()-> {
                while (true) {
                    try {
                        Runnable runnable=queue.take();
                        runnable.run();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
        }
    }
}

检测实现的线程池：

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        MyThreadPool pool=new MyThreadPool(10);
        for (int i = 0; i < 1000; i++) {
            int taskId=i;//注意匿名内部类的变量捕获
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("执行当前任务:"+taskId+"当前线程:"+Thread.currentThread().getName());
                }
            });
        }
    }
}