【Java EE初阶九】多线程案例（线程池）

一、线程池的引入

? ? ? ? 引入池---->主要是为了提高效率；

????????最开始，进程可以解决并发编程的问题，但是代价有点大了，于是引入了 “轻量级进程” ---->线程

????????线程也能解决并发编程的问题，而且线程的开销比进程要小的多，但是如果线程太多，创建销毁线程的频率也会进一步提高，故此线程创建销毁的开销就不能忽视了。

????????为了解决上述问题，大佬们给出了两个解决方案：

? ? ? 1、引入轻量级线程---->也称为纤程/协程（节省了系统调度的开销）

????????协程的本质是程序员在用户态代码中进行调度，不是靠内核的调度器调度的—>节省了许多的调度上的开销；协程是在用户代码中，基于线程封装出来的，可能是N个协程对应1个线程，也可能是N个协程对应M个线程。

? ? ? ? 2、引入 “线程池”

? ? ? 线程池：把我们要使用的线程池提前创建好，这个线程执行完也不要直接释放而是存放到线程池中以备下次继续使用需要用这个线程的时候，再从线程池中拿，不需要的时候，就放在线程池中，并不会销毁它，这样就节省了创建/销毁线程的开销；

????????在这个使用的过程中，并没有真正的频繁创建销毁，而只是从线程池里面取线程使用，等使用完了在还给线程池；

????????为啥从线程池中取线程 比从系统中申请线程的创建更高效呢？

? ? ? ? 下面讲解一下关于用户态和内核态的说明；

????????假设在银行场景中，smallye要去这个银行办理一个业务，一般银行中大堂有复印机；这时，smallye没有带身份证复印件，此时smallye要去搞到身份证复印件，有两个选择：

????????其一选择：把身份证给柜员，让柜员帮smallye复印，但是这个操作是不可控的，可能这个柜员中途被老板安排了其他活，那这个时候，就不能帮smallye复印身份证了，要等忙完老板安排的活，再帮smallye复印身份证；

????????其二选择：smallye自己去大堂中复印身份证，这样就比较可控了，smallye可以很快的去到打印机，立马复印出来，再去办理他的业务。如下图所示：

? ? ? ? 上述例子中大堂就是用户态，柜台就是内核态；

????????从线程池中取线程，是纯用户态代码（可控） ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 通过系统申请创建线程，需要内核完成（不可控有风险）；

2.?线程池的简单介绍

2.1 ThreadPoolExecutor类

? ? ? ? 在java标准库中，ThreadPoolExecutor类表示线程池，ThreadPoolExecutor类是参数最多的构造方法，如下图所示：

? ? ? ? 下面来详细讲解该构造方法里面的参数的具体含义：

?????????1、核心线程数和最大线程数（int corePoolSize，int maximumPoolSize）：

????????corePoolSize：核心线程数：（正式员工线程）

????????maximumPoolSize：最大线程数：（正式员工线程 + 实习员工线程）

? ? ? ? eg：核心线程就是相当于公司里面的正式员工，同时最大线程数里面包含最大线程数和实习员工线程，对于实习员工线程来说就是就是可有可无的，当核心线程全部处于工作状态且还有大量的任务需要新的线程处理的时候，我们就会创建实习员工线程，来帮核心线程处理这些任务；当任务数量较少的时候，核心线程可以闲着，但是实习员工线程全部需要销毁；

????????2、保持存活时间和存活时间的单位（long KeepAliveTime，TimeUnit unit）

????????KeepAliveTime：保持存活时间：（实习生线程允许摸鱼的最大时间）

????????unit：存活时间的单位：可以是hour 、 min 、 s 、 ms

????????3、放任务的队列? ?(BlockkingQueue<Runnable> workQueue:)

????????和定时器类似，线程池中也可以持有多个任务，要执行的任务，使用Runnable来描述任务的主体。

? ? ? ? 4、线程工厂（ThreadFactory，threadFactory）

????????通过这个工厂类创建线程对象（Thread对象），工厂类里面有方法封装了new Thread的操作，同时给Thread设置了一些属性，我们想要创建线程的时候可以直接使用工厂类的方法创建。

? ? ? ? eg：描述一个点，通过数学知识可以用二维坐标和极坐标来表示：二维坐标：（x，y） 极坐标：（r，α）；故此我们通过new一个类来得到一个点，这个类里有两个构造方法，参数分别是（double x，double y），（double r，double α），那么这两个构造方法的参数类型都一样，构成不了重载，如下图所示：

? ? ? ? 以上显示出我们想要给java类提供更多的构造方法，但是受到重载的影响限制，为了解决上述问题，我们引入了“工厂模式”，做一下修改：

????????我们使用static修饰，更改方法名，通过不同的方法名获取类，在方法里new一个类，里面设置一些参数，再返回这个类，如下图所示：

????????这样的类，就称为工厂类，工厂类里面得到类的方法就称为工厂方法。

????????总的来说，通过静态方法来封装new操作，在这个静态方法设置不同的属性，构造对象的过程，就称为工厂模式。

? ? ? ? 5、拒绝策略（RejectExecutionHandler handler）

? ? ? ? 该参数是上述部分参数中最重要的一个；

????????在线程池中有一个阻塞队列，且该队列容纳线程数量有限，如果这个任务队列满了，这时有往线程池中添加任务，这时候线程池要学会拒绝，由拒绝策略，在java标准库中就提供了以下四种拒绝策略，如下图所示：

? ? ? ? 拒绝策略讲解：

????????第一个策略：会直接抛出一个异常，这样，旧的任务执行不了，新的任务也执行不了

????????第二个策略：把新的任务丢给添加任务队列的线程执行，不给入队列，同时旧的任务依然在执行

????????第三个策略：把最旧的任务丢弃，添加最新的任务进来

????????第四个策略：直接把新的任务丢弃了，不执行新的任务，旧的任务会继续执行

2.2?Executors类?

????????ThreadPoolExecutor类本身使用起来比较复杂，java标准库给我们提供了另一个版本：把ThreadPoolExecutor封装了一下，这个类就是Executor工厂类，通过这个类创建出不同的线程池对象，在其内部，已经把ThreadPoolExecutor创建好了，并且设置了一些参数。

????????Executor的简单使用，其中主要方法有一下4个，如图：

? ? ? ? eg：我们使用newFixedThreadPool(4)方法创建4固定个线程数目的线程池，再往里添加任务：

package thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadDemo32 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(4);
        service.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("smallye");
            }
        });
    }
}

? ? ? ? 结果如下：

? ? ? ? 至于如何确定使用Executor或ThreadPoolExecutor，主要是看具体的情况；

2.3?线程池的执行流程

? ? ? ? 主要有以下四个情况：
????????1、当有任务要让线程池里面的线程执行时，会比较工作线程数和核心线程数， ? ? ? ? ? ? ? ? ? ? 如果工作线程数 < 核心线程数，则会直接安排线程去执行这个任务。

????????2、当工作线程数 > 核心线程数，即线程池中的核心线程数满了，会添加进阻塞任务队列中，添加任务队列前也会判断任务队列是不是空，是空就阻塞等待。

????????3、如果线程池中的存活线程数 == 核心线程数，并且阻塞任务队列也满了，此时会判断是否到了最大线程数：maximumPoolSize，如果没有到达，就会让非核心线程去执行这个任务。

????????4、如果当前线程数到达了最大线程数，则会执行拒绝策略

2.4 关于线程池中创建多少线程

? ? ? ? 这是我们就需要关注该进程是cpu密集型还是io密集型；
????????假设一个进程中，所有线程都是cpu密集型，这时每个线程的工作都是在cpu上执行的，此时，线程池中的数目就不应该超过N（cpu的逻辑核心线程数）

? ? ? ? 假设一个进程中，所有线程都是IO密集型的，这时每个线程的大部分工作都是在等待IO，此时，线程池中的数目就可以远远超过N（cpu的逻辑核心线程数）

????????实际上一个进程中的线程，有cpu密集型的，也有IO密集型的，只是比例不同。由于程序的复杂性，很难直接对线程池进行预估，更准确的做法是通过实验 / 测试的方法，找出合适的线程数目；

3. 线程池的模拟实现

? ? ? ? 我们写代码实现一个简单的线程池：（直接写一个固定线程数目的线程池-->暂时不考虑线程的增加和减少）,其中具体思路主要一下步骤：

1. 提供构造方法，指定创建多少个线程池
2. 在构造方法中，把这些线程都创建好
3. 有一个阻塞队列，能够持有要执行的任务
4. 提供submit方法，可以添加新的执行任务；

3.1?阻塞队列--->存放要执行的任务

// 就是一个用来保存任务的队列.
    private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(1000);

3.2?submit方法--->添加任务的方法，任务添加到队列中

  public void submit(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }

3.3?构造方法--->指定创建多少个线程，线程在这个构造方法中都创建好了

// 通过 n 指定创建多少个线程
    public MyThreadPoolExecutor(int n) {
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(() -> {
                // 线程要做的事情就是把任务队列中的任务不停的取出来, 并且进行执行
                while (true) {
                    try {
                        // 此处的 take 带有阻塞功能的.
                        // 如果队列为 空, 此处的 take 就会阻塞.
                        Runnable runnable = queue.take();
                        // 取出一个任务就执行一个任务即可
                        runnable.run();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
            threadList.add(t);
        }
    }

????????线程里面，取出一个任务就执行这个任务，如果队列里没有任务，就会阻塞等待，等有任务，再执行任务，如此循环往复；每创建一个线程，都要放进链表中，也要记得start,开启线程。

3.4 存放线程的链表--->每创建一个线程都放进链表中，这样也能让我们找到某个线程?

//存放线程的链表
List<Thread> list = new ArrayList<>();

3.5 完整版代码

class MyThreadPoolExecutor {
    private List<Thread> threadList = new ArrayList<>();

    // 就是一个用来保存任务的队列.
    private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(1000);

    // 通过 n 指定创建多少个线程
    public MyThreadPoolExecutor(int n) {
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(() -> {
                // 线程要做的事情就是把任务队列中的任务不停的取出来, 并且进行执行
                while (true) {
                    try {
                        // 此处的 take 带有阻塞功能的.
                        // 如果队列为 空, 此处的 take 就会阻塞.
                        Runnable runnable = queue.take();
                        // 取出一个任务就执行一个任务即可
                        runnable.run();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
            threadList.add(t);
        }
    }

    public void submit(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }
}

public class ThreadDemo33 {
//指定线程池的数目为4个线程，添加1000次任务到阻塞队列中，
//让着4个线程从阻塞队列中拿任务，再执行任务
//任务：打印0~1000，并显示是哪个线程打印的；
    public static void main(String[] args) throws InterruptedException {
        MyThreadPoolExecutor executor = new MyThreadPoolExecutor(4);
        for (int i = 0; i < 1000; i++) {
            int n = i;
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("执行任务" + n + " , 当前线程为: " + Thread.currentThread().getName());
                }
            });
        }
    }
}

? ? ? ? 结果如下：

ps:关于线程池案例的内容就到这里了，如果大家感兴趣的话，就请一键三连哦！！！