线程池概念、线程池的不同创建方式、线程池的拒绝策略

文章目录

💐线程池概念以及什么是工厂模式
💐标准库中的线程池
💐什么是工厂模式？
💐ThreadPoolExecutor
💐模拟实现线程池

💐线程池概念以及什么是工厂模式

线程的诞生是因为，频繁的创建进程太重量了(开销较大),所以引入了线程，但是呢，对于线程来讲，如果更加频繁的创建和销毁，那么开销也会慢慢的变大，所以，又引入了两种经典的方法来进一步提高：

1.协程：又称为轻量级线程，线程比较轻量是因为线程省略了分配资源的环节，而协程它在着基础上又省略了操作系统调度执行的环节，由程序员自己调度；在Java中呢，主要使用线程池，所以对于协程只是简单提一下；

2.线程池：

举一个例子：

假如我是一个很漂亮的妹子，又有许多的男生正在追我，然后我就选择了一个男生A做我男朋友，但是呢，经过一段时间之后，我就腻了，就想要和男生B谈恋爱，所以，我就和男生A提出了分手，然后和男生B培养感情，等到有了感情基础，等有了感情基础后就拿下男生B，但是，过来一段时间后，我又想和男生C谈恋爱，所以就接着重复上面的套路，先培养感情等等………

而对于上面这种换男朋友的方式，感觉效率太慢，所以，我就有了一种新的方式，在和男生A谈恋爱的同时，偷偷的和男生B、C、D等多个男生培养感情，等到我向和谁谈恋爱时，那不就是捅破一层窗户纸的事情么，就可以挑选一个直接谈恋爱，这样的效率不久高了很多么，所以，对于偷偷的和我培养感情的这群男生也就可以称为“备胎池”；

而我们的线程池也是上面这种模式，在向池中添加任务时，直接从线程池中拿线程就可以了，就不比再创建了，直接拿过来使用即可，这样也就降低了线程创建的开销；所以线程池的就是先把线程创建好，放进池子里，等到后续想要使用时，直接从池子里取；

这里就会有一个问题：为啥从线程池里面取线程比创建线程效率高？

首先，创建新的线程这个动作，是内核态+用户态相互配合完成的；

而从线程池中取这个动作，是用户态操作完成的；

所以这里就涉及到了两个新名词，什么是用户态，什么是内核态

如果一段程序是在系统内核中完成的，此时就称为内核态

如果不是，则称为用户态；

而操作系统呢，是由内核+配套的应用程序组成的，创建线程，就需要调用系统API,进入到内核中，按照内核态的方式来完成一系列的动作；

但是，为什么内核态操作的效率比较低呢？请看下图

💐标准库中的线程池

在Java中，提供了一个类——Executors创建线程池；但是，线程池对象的创建并不是直接new出来的，而是通过一个方法的返回值，返回了一个线程池对象；

public class MyThreadPool {
    public static void main(String[] args) {
        //创建一个动态的线程池
        ExecutorService es = Executors.newCachedThreadPool();
        es.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        });
    }
}

创建线程池对象分为以下步骤：

1.使用Executors.newCachedThreadPool 创建出一个动态增长的线程池，为什么要用Executors.newCachedThreadPool的方式创建线程池，而不是直接new Executors？这里就涉及到了一个设计模式——工厂模式：

💐什么是工厂模式？

工厂模式：定义一个工厂类，通过调用工厂类中的不同方法来实现对象的实例化，从而创建出不同作用的对象；

举个例子，我们在创建对象时，会使用new关键字，通过构造方法来创建对象，但是使用构造方法创建对象会又很大的局限性，举个例子：假如我现在想要使用笛卡尔坐标来创建一个点对象，代码如下：

public class Point {
    //笛卡尔坐标系需要提供一个x，y坐标
    private int x;
    private int y;
    //通过笛卡尔坐标的方式创建一个对象
    public Point(int x, int y) {};
}

但是，我现在又想通过极坐标的方式创建点对象

public class Point {
    private int x;
    private int y;
    //通过笛卡尔坐标的方式创建一个对象
    public Point(int x, int y) {};
    //极坐标的方式就需要提供一个半径和角度
    public Point(int r, int a) {};
}

但是以上这种方式就会编译错误，因为，如果想要使用多种构造方法的方式创建对象的话，就需要将构造方法重载，而重载的条件是要保证参数列表的类型或者个数不同，所以以上代码是行不通过的，针对这种问题，就可以利用工厂模式解决

public class Point {
    private int x;
    private int y;
    
    public void setX(int x) {
        this.x = x;
    }
    public void setY(int y) {
        this.y = y;
    }
}

//创建一个点对象的工厂
class PointFactor{
    //通过笛卡尔坐标系创建对象
    public static Point newPointByXY(int x, int y) {
        Point p = new Point();
        //对Point中的属性进行初始化
        p.setX(x);
        p.setY(y); 
        return p;
    }
    //通过极坐标创建对象
    public static Point newPointByRA(int r, int a) {
        Point p = new Point();
        p.setX(r);
        p.setY(a);
        return p;
    }
}

//测试类
class Main{
    public static void main(String[] args) {
        //这样通过调用点工厂中不同方法，就可以根据不同的方式创建出对象
        Point point1 = PointFactor.newPointByXY(5,2);
        Point point2 = PointFactor.newPointByRA(10,20);
    }
}

回到这里的线池：

public class MyThreadPool {
    public static void main(String[] args) {
        //创建一个动态的线程池
        ExecutorService es = Executors.newCachedThreadPool();
        es.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        });
    }
}

在线程池中，也提供了几个比较重要的方法：

（重点）创建线程池也提供了几种不同的方式：

newCachedThreadPool() 创建线程数目动态增长的线程池

这种方式创建的线程池，池子中的线程会根据你添加的任务的需要，自动创建线程出来，线程结束以后也不会立即销毁，而是会在池子中保留一段时间，以备后续再随时使用；
newFixedThreadPoll() 创建固定线程数的线程池
newSingleThreadPool() 创建只包含一个线程的线程池
newScheduleThreadPool() 类似于定时器，只不过不是一个扫描线程，而是多个扫描线程执行时间到的任务

方法的返回值类型是ExecutorService

通过ExecutorService定义的对象调用submit()方法注册一个任务到线程池中

    public static void main(String[] args) {
        //创建一个动态的线程池
        ExecutorService es1 = Executors.newCachedThreadPool();
        ExecutorService es2 = Executors.newFixedThreadPool(5);
        ExecutorService es3 = Executors.newSingleThreadExecutor();
        ExecutorService es4 = Executors.newScheduledThreadPool(6);//指定扫描线程的数量
        
    }

上述几个使用工厂方法创建的线程池，本质上都是对一个类进行了封装，这个类就是——ThreadPoolExecutor

这个类的功能非常丰富，提供了很多不同参数方法，上述的几个工厂方法呢，其实就是给这个ThreadPoolExecutor 类填写了不同的构造参数从而创建出了不同的线程池；

接下来就看一下ThreadPoolExecutor的使用方法👇

💐ThreadPoolExecutor

ThreadPoolExecutor的构造方法中提供了很多可选的参数，进一步的细化了线程池的设定，下面针对这些参数进行一个讲解：

在这里插入图片描述

上图就是ThreadPoolExecutor的所有构造方法，也可以看到，最后一个构造方法的参数最多，并且当中的参数也都包含了其他三个方法的参数，所以，这里针对最后一个方法参数进行讲解：

int corePoolSize :核心线程数
int maximumPoolSize :最大线程数目

在一个线程池中，是有多个线程的，以上两个参数就指定了线程池中线程数目的范围，最少有corePoolSize个线程，最多不会超过maxMumPoolSize个线程
long keepAliveTime 和 TimeUnit unit :空余线程存活的时间以及时间的单位

在创建线程时，默认会先使用核心线程数，上面提到过，当任务执行结束后，线程不会立马销毁，而是会有一个保留的时间，一方面是为了如果后续再需要使用时，就不用再进行创建，另一方面是，当保留时间到了以后，进行销毁，也减少了资源消耗，后续使用时再进行创建即可
BlockingQueue workQueue ：阻塞队列

当使用submit向线程池中添加任务时，如果任务个数少于核心线程数，那么会创建新的线程去执行任务，如果任务个数超过了核心线程数，就会先添加到阻塞队列中，然后工作线程从队列中取出任务执行，如果任务不能排队等候，那么也会创建一个新的线程，前提是不会超过最大的线程数，需要注意的是，这里的队列不光可以是阻塞队列，还可以是其他的队列，例如如果需要使用优先级就可以设置为：PriorityBlockingQueue，如果任务数目变动不大就可以使用：ArrayBlockingQueue，如果任务数目变动较大就可以使用：LinkedBlockingQueue;
ThreadFactory threadFactory ：线程工厂类

这个类也是工厂模式的体现，由ThreadFactory这个工厂类来创建线程，使用工厂类创建线程，主要是对线程的属性进行设置，通过这个类对这些属性进行了封装，就不需要我们手动进行设置；
ThreadPoolExecutor.DiscardPolicy ：拒绝策略

一个线程池中的线程数量是有上限的，当线程数量达到上限后，如果还继续往线程池中添加任务，那么针对不同的拒绝策略就会出现不同的效果；

（重点）任务策略分为：

这四种拒绝策略使用了类来实现，想要使用哪种策略，直接创建出对象，将对象传过去即可；

下面针对这四种策略进行一个讲解：

ThreadPoolExecutor.AbortPolicy ：如果队列已经满了，直接抛出异常

ThreadPoolExecutor.CallerRunsPolicy ：新添加的任务由调用任务的线程执行

ThreadPoolExecutor.DiscardOldestPolicy ：丢弃任务队列中最老的任务

ThreadPoolExecutor.DiscardPolicy ：丢弃新添7加的任务

上面讲过，针对于线程池可以设置线程的数目，但是，这个数目设置成多少合适呢？

针对这个问题，网上有很多的答案，假设CPU的逻辑核心数是N，线程数目的设置就有多个答案，例如：

N个，N+1个，N+2个，2N个等等；

针对以上答案，没有一个是正确的，因为这需要根据项目代码进行设置，一个线程执行的代码主要分为两类：

CPU 密集型

CPU 密集型，代码里面的主要逻辑都是在算数运算/逻辑判断
IO 密集型

IO 密集型，代码里面的主要逻辑都是在进行IO操作

如果代码是都是CPU密集型，这时设置的线程数目就不能超过N，如果代码都是IO密集型的，此时设置的线程数目就可以超过N，而在现实中，没有代码都是纯CPU密集型和纯IO密集型的，同时，我们也无法知道有多少代码是CPU密集，有多少代码是IO密集的；

所以要想知道该设置多少线程数，正确的做法就是用实验的方式，尝试改变线程池中不同线程的数目，来观察出哪种数目更合适；

💐模拟实现线程池

这里来模拟一个简单的newFixedThreadPool()版本的线程池，步骤：

创建一个MyThreadPool,描述一个线程池

使用一个阻塞队列组织所有的任务

public class MyThreadPool {
    //创建一个阻塞队列组织所有的任务
    private BlockingDeque<Runnable> queue = new LinkedBlockingDeque<>();
    public MyThreadPool(int n) {
        //创建n个线程
        for(int i = 0; i < n; i++) {
            Thread thread = new Thread(() -> {
                try {

                    Runnable runnable = queue.take();
                    runnable.run();

                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            });
            thread.start();
        }
    }
    public void submit(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }
    public static void main(String[] args) throws InterruptedException {
        MyThreadPool myThreadPool = new MyThreadPool(4);
        for(int i = 0; i < 100; i++) {
            int n = i;
            myThreadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(n);
                }
            });
        }
    }
}