JAVAEE——线程池

线程池的概念

什么是线程池？

我们先来说一下什么是线程池，线程池这个名字大家应该能够有一定的了解，我们计算机中进程会用到池化技术，

所谓池化技术，它其实就跟蓄水池一样，也就是提前创建好一批线程，并且不让其销毁，等到需要他们去做任务的时候再将其唤醒，这样子就可以有效的提高性能，至于为什么可以提高性能呢？我们通过一个例子来说明一下。
比如说我们要去银行取钱，那么有两种方式第一种就是通过柜台取钱，第二种就是通过ATM机自动取钱。


这时候就有了两种应对方式，如果是柜台的话你需要签名，出示证件，初始银行卡，然后输入密码，确认额度等等。办理起来就会很麻烦而且还得等待上班的时候才可以，但是我们老百姓就想取个多的话一两千少的话几百块因此不希望这么麻烦，所以就可以去ATM机去，这时候ATM就很方便只需要输入密码即可。而线程池也是这个道理，我们会提前创造好一部分线程放入我们创造的一块内存空间中，等到需要的时候在调用这个线程池里的线程，这样子我们就可以大幅度的缩小时间的消耗非常的高效。

标准库中的线程池

线程池的创建

首先我们来说一下如何创建一个线程池呢？这里涉及到了几个知识点我们来说一下。

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

我们来写一段代码。

public class Main {
    public static void main(String[] args) {
        ExecutorService executorService=Executors.newFixedThreadPool(10);
    }
}

这样子我们就创建了一个含有十个线程的线程池，这时候有的同学就有疑问了，为什么这里我们创建线程池的时候涉及到了两个类，一般不都是一个类然后new一下吗？就像我们创建线程一样，这是为什么呢？这里涉及到了一个模式叫做工厂模式

工厂模式

什么是工厂模式呢？我们举个例子假设说我们去买个本子，我们想买有一百张纸的本子，这时候店家肯定不会像A4纸那样给我们一张一张的本子肯定是，生产了一百张纸然后将这一百张纸进行装订和包装从而交到我们手上。那么什么地方要用到工厂模式呢？

工厂模式的用途

我们应该都知道函数重载吧。那么如果说存在这样一种情景，就是你需要写一个除法算法但是两个除法算法的要求不一样第一个方法的要求是返回值必须得保留两位小数，第二个方法的要求是保留三位小数并且必须和第一个方法的名字一样用重载实现。这时候就会有人说了怎么会有这么离谱的要求，是的如果放在这里干说确实很离谱但是如果是类里面的构造方法呢？构造方法的方法名称一样唯一能构成重载的就是参数类型，可是会不会有一些场景即使是参数类型也完全一样呢？答案是肯定的并且由于这是构造方法导致我们的函数名称还不能发生改变，因此最好的解决办法是什么呢？那就是再创造一个类这个类里面包含了很多我们需要的方法，接下来我们想要创建哪种类型只需要从这个类里面进行完成就可以了。这个就是工厂模式也就是我们上面的那个代码的来源。

线程池涉及到的类有哪些

我们打开源代码来看一些东西

Executor接口

任务执行器（Executor）是一个接口，位于java.util.concurrent包下，它的作用主要是为我们提供任务与执行机制（包括线程使用和调度细节）之间的解耦。比如我们定义了一个任务，我们是通过线程池来执行该任务，还是直接创线程来执行该任务呢？通过Executor就能为任务提供不同的执行机制。执行器的实现方式各种各样，常见的包括同步执行器、一对一执行器、线程池执行器、串行执行器等等。这个接口内部只有一个方法。如下图

ExecutorService接口

ExecutorService 主要用来管理和控制线程，是Java并发编程的重要工具，在实际业务中， ExecutorService 的使用场景非常广泛，比如，经常需要处理大量的用户请求，而每个请求都需要一个独立的线程去处理，如果直接为每个请求创建一个新的线程，会消耗大量的系统资源，而且管理起来也非常麻烦，此时，就可以使用ExecutorService来解决问题。这时候我们有个问题这个东西是个接口啊，接口是不能实例化处对象的，那么为什么刚刚那个工厂类中的创建线程池方法可以直接返回给这个接口呢？其实那个方法里所创造的对象根本不是这个接口的实例化，而是它的子类。因此这里其实涉及到了一个向上转型。

Executors工厂类

Executors是Java中用于创建线程池的工厂类，它提供了一系列的静态工厂方法，用于创建不同类型的线程池。这些工厂方法隐藏了线程池的复杂性，使得线程池的创建变得非常简单。Executors工厂类提供的线程

• newCachedThreadPool()：创建一个可缓存的线程池。这个线程池的线程数量可以根据需要自动扩展，如果有可用的空闲线程，就会重用它们；如果没有可用的线程，就会创建一个新线程。适用于执行大量的短期异步任务。
• newSingleThreadExecutor()：创建一个单线程的线程池。这个线程池中只包含一个线程，用于串行执行任务。适用于需要按顺序执行任务的场景。
• newFixedThreadPool(int nThreads)：创建一个固定大小的线程池，其中包含指定数量的线程。线程数量是固定的，不会自动扩展。适用于执行固定数量的长期任务。
• newScheduledThreadPool(int corePoolSize)：创建一个固定大小的线程池，用于定时执行任务。线程数量固定，不会自动扩展。适用于定时执行任务的场景。
• newWorkStealingPool(int parallelism)：创建一个工作窃取线程池，线程数量根据CPU核心数动态调整。适用于CPU密集型的任务。
• newSingleThreadScheduledExecutor()：创建一个单线程的定时执行线程池。只包含一个线程，用于串行定时执行任务。

AbstractExecutorService虚类

AbstractExecutorService实现了ExecutorService和Executor接口的基本方法，ThreadPoolExecute和ForkJoinPool继承AbstractExecutorService就可以减少实现的复杂度，接口适配器模式

ThreadPoolExecutor普通类

他是线程池的真正的实现类内部有很多实现细节

ThreadPoolExecutor内部的实现4个拒绝策略

我们保存任务

CallerRunsPolicy：由调用execute方法提交任务的线程来执行这个任务
AbortPolicy：抛出异常RejectedExecutionException拒绝提交任务
DiscardPolicy：直接抛弃任务，不做任何处理
DiscardOldestPolicy：去除任务队列中的第一个任务，重新提交

线程池的实现

实现线程池

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class threadPool {
    private BlockingQueue<Runnable>blockingQueue=new ArrayBlockingQueue<>(10000);
    public void submit(Runnable runnable){
        try {
            blockingQueue.put(runnable);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
    public threadPool(int n){
        for(int i=0;i<4;i++){
            Thread thread=new Thread(()->{
                while(true){
                    try {
                        Runnable runnable=blockingQueue.take();
                        runnable.run();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
            thread.start();
        }
    }

}

import java.beans.ExceptionListener;
import java.util.Objects;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class Main {
    public static void main(String[] args) {
            threadPool th=new threadPool(100);
            for(int i=0;i<1000;i++){
                int id=i;
                th.submit(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("I love lele"+id);
                    }
                });
            }
    }
}

那么以上代码就是我们创建线程池的代码这个代码结构相对是比较简单的。一个阻塞队列用来存储执行的任务然后创建线程去执行任务因为阻塞队列是线程安全的，因此当无任务的时候创建的线程会陷入等待状态中。