多线程（初阶九：线程池）

假设在银行场景中，滑稽老铁要去这个银行办理一个业务，一般银行中大堂有复印机；这时，滑稽老铁没有带身份证复印件，此时滑稽老铁要去搞到身份证复印件，有两个选择，其一选择：把身份证给柜员，让柜员帮滑稽老铁复印，但是这个操作是不可控的，可能这个柜员中途被老板安排了其他活，那这个时候，就不能帮滑稽老铁复印身份证了，要等忙完老板安排的活，再帮滑稽老铁复印身份证；其二选择：滑稽老铁自己去大堂中复印身份证，这样就比较可控了，滑稽老铁可以很快的去到打印机，立马复印出来，再去办理他的业务。如图：

这里的大堂就是用户态，柜台就是内核态，从线程池中取线程，是纯用户态代码（可控）通过系统申请创建线程，需要内核完成（不可控）

二、线程池的简单介绍

1、ThreadPoolExecutor类

ThreadPoolExecutor参数最多的构造方法，明白了这个构造方法，其他构造方法的参数也就都明白了，如图：

（1）核心线程数和最大线程数：

corePoolSize核心线程数：正式员工线程

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

举个栗子：一个公司中有10个正式员工，这10个正式员工是不能随便开除的，当这10个正式员工忙不过来的时候，公司为了降低成本，会招聘实习员工，而这几个实习员工是可以随便开除的，当公司稳定一段时间不忙后，就会开除几个实习员工。

（2）保持存活时间和存活时间的单位

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

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

（3）放任务的队列

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

（4）线程工厂

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

举个栗子：

描述一个点，可以用二维坐标和极坐标来表示：二维坐标：（x，y）极坐标：（r，α）

这里，通过new一个类来得到一个点，这个类里有两个构造方法，参数分别是（double x，double y），（double r，double α），那么这两个构造方法的参数类型都一样，构成不了重载，如图：

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

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

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

（5）拒绝策略

在线程池中有一个阻塞队列，这个队列容纳线程有上限，如果这个任务队列满了，这时有往再添加任务，会发生啥事？

这就引出了拒绝策略，在线程池中，会有四个拒绝策略，如图：

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

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

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

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

2、Executors类

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

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

我们创建一个固定线程数目的线程池，再往里添加任务

代码：

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

执行结果：

那啥时候使用Executor，啥时候使用ThreadPoolExecutor呢？

网上流传了阿里巴巴java开发编程规范，里面写了不建议使用Executor，而且一定要使用ThreadPoolExecutor，里面说用ThreadPoolExecutor意味着一切都在掌控之中，可以避免一些不必要的因素；我们可以作为参考，不必奉为金科玉律，他们两各有各的优缺点，这也要以以后入职的公司编程规范为准。

3、线程池的执行流程

（1）当有有任务要让线程池里面的线程执行时，会比较工作线程数和核心线程数，如果工作线程数 < 核心线程数，则会直接安排线程去执行这个任务。

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

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

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

4、讨论线程池中创建多少线程合适

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

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

上述情况都是极端情况，实际上一个进程中的线程，有cpu密集型的，也有IO密集型的，只是比例不同。由于程序的复杂性，很难直接对线程池进行预估，更准确的做法是通过实验 / 测试的方法，找出合适的线程数目；也就是尝试给线程池设定不同的线程，对不同线程情况线程池执行的效率、性能进行评估，找到合适的线程数目。

三、线程池的模拟实现

模拟线程数目固定的线程池

（1）阻塞队列：存放要执行的任务

代码：

//阻塞队列：存放要执行的任务
private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(5);

（2）submit方法：添加任务的方法，任务添加到队列中

代码：

//提供submit方法，可以添加任务
public void submit(Runnable runnable) throws InterruptedException {
    queue.put(runnable);
}

（3）构造方法：指定创建多少个线程，线程在这个构造方法中都创建好了

public MyThreadPoolExecutor(int n) {
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(() -> {
                while (true) {
                    try {
                        //取出一个任务
                        Runnable runnable = queue.take();
                        //执行任务
                        runnable.run();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
            list.add(t);
        }
    }

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

（4）存放线程的链表：每创建一个线程都放进链表中，这样也能让我们找到某个线程

代码：

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

（5）最终代码（ + 测试用例）

class MyThreadPoolExecutor {
    //存放线程的链表
    List<Thread> list = new ArrayList<>();
    //阻塞队列：存放要执行的任务
    private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(5);
    //提供submit方法，可以添加任务
    public void submit(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }
    public MyThreadPoolExecutor(int n) {
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(() -> {
                while (true) {
                    try {
                        //取出一个任务
                        Runnable runnable = queue.take();
                        //执行任务
                        runnable.run();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
            list.add(t);
        }
    }
}
public class MyThreadPoolExecutorTest {
    public static void main(String[] args) throws InterruptedException {
        MyThreadPoolExecutor myThreadPoolExecutor = new MyThreadPoolExecutor(4);
        for (int i = 0; i < 1000; i++) {
            //变量捕获
            int n = i;
            myThreadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("执行任务:" + n + "，当前线程：" + Thread.currentThread().getName());
                }
            });
        }
    }
}

测试用例：指定线程池的数目为4个线程，添加1000次任务到阻塞队列中，让着4个线程从阻塞队列中拿任务，再执行任务，任务：打印0~1000，并显示是哪个线程打印的；

注意：这里我们打印那里我们不能直接放 i ，这里涉及到变量捕获，不能编译通过，但他们可以在循环里创建一个变量，把 i 的值赋值给这个变量，再打印 n，这样每循环一次，都会创建一个成员变量，这个成员变量也不会变，预期也和我们想要预期效果一样。

执行结果，如图：

可以看到，并不是顺序打印1~1000的，因为不同线程拿到任务的时机不同，多线程执行的顺序也是随机的。