《javaEE篇》--线程池

喝养乐多长不高

已于 2024-08-25 22:16:52 修改

阅读量2.3k

点赞数 39

文章标签： java 开发语言 java-ee jvm 线程池

于 2024-08-25 09:58:45 首次发布

本文链接：https://blog.csdn.net/hyldzbg/article/details/141368984

版权

线程池是什么

线程的诞生是因为进程创建和销毁的成本太大，但是也是相对而言，如果频繁的创建和销毁线程那么这个成本就不能忽略了。

一般有两种方法来进一步提高效率，一种是协程(这里不多做讨论),另一种就是线程池

假如说有一个学校食堂窗口的老板想到给学生提供外卖服务，而且有一个奇妙的想法，每当需要送外卖就现场雇一个学生来送，然后解雇。(就相当于平时的有一个任务就创建一个线程来处理)，但是老板还是觉得频繁的雇佣和解雇学生的成本太大，于是老板又有一个点子。指定一个指标，外卖员的人数扩张到3个人，但还是随着外卖的数量逐步雇人。于是再有外卖来了老板就看，如果外卖员不足3人，就雇一个去送，若有3个人了，就先把外卖放到一边，等3个外卖员空闲时在送。这样的方法就类似于线程池。

这样把线程创建好，放在“池子”里，后续用的时候直接从池子里取就好，不用系统进行创建，不用时还是放到池子里，不用系统销毁。那么为什么从池子取的效率就比创建新线程高？因为从池子取这个动作，是纯用户态的操作，而创建新的线程，这个动作则是，需要用户态+内核态互相配合。

线程池的优势

线程池最大的好处就是减少每次启动、销毁线程的损耗。
当有任务来时，不需要等待新线程的创建，利用已创建的线程就可以执行
方便对线程进行统一管理和调度

工厂模式

线程池对象不是我们直接new的，而是专门通过一个方法，返回一个线程池对象，这种设计模式，就叫做工厂模式。

我们通常创建对象，使用new关键字。使用new就会触发构造方法，但是构造方法存在一定局限性。很多时候构造一个对象，希望有多种构造方式，多种方式就需要多个版本的构造方法来实现。但是构造方法要求方法的名字必须是类名，不同构造方法，就只能通过重载的方式来区分了。

实践中，一般单独搞一个类，给这个类搞一些静态方法，由这些静态方法负责构造出对象

工厂模式详解

线程池的创建

使用 Executors.newFixedThreadPool(10) 能创建出固定包含 10 个线程的线程池.
返回值类型为 ExecutorService
通过 ExecutorService.submit 可以注册一个任务到线程池中

ExecutorService pool = Executors.newFixedThreadPool(10);
pool.submit(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
});

Executors 创建线程池的几种方式

newFixedThreadPool: 创建固定线程数的线程池
newCachedThreadPool: 创建线程数目动态增长的线程池.(随着往线程池里添加任务，这个线程池中的线程会根据需要自动被创建出来，创建出来之后也不会着急销毁，而是会在池子里保留一定时间，以备随时使用)
newSingleThreadExecutor: 创建只包含单个线程的线程池.
newScheduledThreadPool: 设定延迟时间后执行命令，或者定期执行命令. 是进阶版的 Timer.

上述几个工厂方法生成的线程池，本质上是 ThreadPoolExecutor 类的封装，这个类功能非常丰富，提供了很多参数，标准库上述的几个工厂方法，其实就是给这个类填写了不同的参数用来构造线程池。

(线程池的真正实现类是ThreadPoolExecutor).

线程池的参数

可见线程池有许多的参数具体如下：

corePoolSize(核心线程数):

线程池中会有一个最小的线程数量(核心线程数),即使这些线程处于空闲状态，也不会被销毁(除非设置了allowCoreThreadTimeOut为true)。当提交一个任务交给线程池后，线程池首先会检查当前线程数是否到达核心线程数，如果没有则创建一个新线程来处理这个任务。

maximumPoolSize(最大线程数):

如果当前线程数已经达到核心线程数，此时继续有任务添加，则会被缓存到工作队列中，如果队列也已经满了，就会创建一个新线程来处理这个任务(不是核心线程)，但是线程不会无止尽的创建，最多创建的线程的数量就是有maximumPoolSize定的

keepAliveTime(线程限制超时时长):

如果一个线程处于空闲状态，并且当前线程数大于核心线程数(该空闲线程不是核心线程)，那么在一定时间后该非核心线程将会被销毁(如果将allowCoreThreadTimeOut为true，一定时间后，空闲的核心线程也会被销毁)。这个时间就是keepAliveTime

unit(keepAliveTime的单位):

用来指定keepAliveTime的单位的，一般常用的单位有，TimeUnit.MILLISECONDS(毫秒)，TimeUnit.SECONDS(秒)，TimeUnit.MINUTES(分)。

workQueue(工作队列):

用来存放线程池中的任务的，可以根据需要灵活设置这里的队列是什么。需要优先级，就可以设置PriorityBlockingQueue，不需要优先级而且任务数目相对固定，可以使用ArrayBlockingQueue，如果不需要优先级，并且任务数目变动较大，可以使用LinkedBlockingQueue

threadFactory(线程工厂):

工厂模式的体现，使用threadFactory作为工厂类，由这个类负责创建线程，主要是为了，在创建线程过程中，对线程的属性做出一些修改。可以更方便的创建线程。

handler(线程池的拒绝策略):

一个线程池的任务容量达到上限，继续往线程池里添加任务的时候，会出现什么效果，JDK提供了4种策略

拒绝策略

当线程池的线程数目达到最大线程数时，所执行的策略。 Executors给我们提供了四种常用的拒绝策略。

ThreadPoolExecutor.AbortPolicy(默认)：直接抛出RejectedExecutionException 异常
ThreadPoolExecutor.CallerRunsPolicy：新添加的任务，由新添加任务的线程负责执行
ThreadPoolExecutor.DiscarOldestPolicy：丢弃任务队列中最老的元素
ThreadPoolExecutor.DiscarPolicy：丢弃当前新加的任务

线程数目

在使用线程池时，需要设置线程数目，那么设置多少合适？N？N+1？2N？都不是。

一个线程执行的代码主要有两大类：

cpu密集型：代码的主要逻辑是在进行算术运算/逻辑判断
IO密集型：代码主要进行的是IO操作

假设一个线程的所有代码都是cpu密集型，这时线程池的线程数量不应该超过N，设置比N更大时，也无法提高效率了(cpu吃满了)此时更多的线程反而增加了调度的开销.

再假设一个线程的代码都是IO密集型。这时程序不吃cpu，设置的线程数就可以超过N

所以代码不同线程池的线程数目设置就不同，就无法知道一个代码具体内容是cpu聚集多一些，还是IO聚集多以一些。

正确的做法应该是：使用实验的方式，对程序进行性能测试，实验过程中尝试修改不同的线程池线程数目，看看那种情况下最符合要求

实现简单线程池

class MyThreadPool{
    //任务队列
    private BlockingQueue<Runnable> queue= new ArrayBlockingQueue<>(1);
    //通过这个方法，把任务添加到队列中
    public void submit(Runnable runnable) throws InterruptedException {
        //此处的拒绝策略是阻塞等待
        queue.put(runnable);
    }
    public MyThreadPool(int num){
        //创建出n个线程负责执行上述任务
        for (int i = 0; i < num; i++) {
            Thread t = new Thread(() -> {
                //让这个线程从队列中消费任务
                try {
                   while(!Thread.interrupted()){
                       Runnable runnable = queue.take();
                       runnable.run();
                   }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            });
            t.start();
        }
    }
}

public static void main(String[] args) throws InterruptedException {
        MyThreadPool myThreadPool = new MyThreadPool(4);
        for (int i = 0; i < 100; i++) {
            int id = i;
            Thread.sleep(500);
            myThreadPool.submit(new Runnable() {
                @Override
                public void run() {
                    //这里不能使用i因为匿名内部类的变量捕获，类里要使用不变值
                    System.out.println("id" + id);
                }
            });
        }

    }