【多线程 十】线程池的应用以及其原理剖析

1、线程池概念

（1）线程池管理器

用于创建并管理线程池，包括创建线程池、销毁线程池、添加新任务；

（2）工作线程

线程池中线程，在没有任务时处于等待状态，可以循环的执行任务

（3）任务接口

每个任务必须实现的接口，以供工作线程调度任务执行，它主要规定了任务入口，任务执行完后的收尾工作，任务的执行状态等

（4）任务队列

用于存放没有处理的任务，提供一种缓冲机制。

2、线程池API

（1）接口定义和实现类

类型	名称	描述
接口	Excutor	定义了 执行任务的方法execute
接口	ExcutorService	扩展了Callable、Future、关闭方法
接口	ScheduledExecutorService	增加了定时任务的相关的方法
实现类	ThreadPoolExcutor	基础、标准的线程池实现（我们用的）
实现类	ScheduledThreadPoolExcutor	实现了ScheduledExecutorService中相关定时任务的方法（定时的时候用到）

eg:

 ExecutorService threadPoolExecutor = new ThreadPoolExecutor(3, 5, 1L, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

上面其实就是创建了一个核心线程数为3，最大线程为5，有效时间为1s，队列容量为3，拒绝策略为AbortPolicy的一个线程池，后边对这些具体的参数会介绍

（2）Executors工具类

上面是自己实例化了一个线程池，我们也可以用Executors创建线程池的工厂类，常用方法如下：

newFixedThreadPool（int nThreads）:

	创建一个固定大小，任务队列容量 无界的线程池。核心线程数=最大线程数

newCachedThreadPool()

创建一个大小无界的缓冲线程池，它的任务队列是一个同步队列，任务加入加入到池中，如果池中有空闲线程， 则用空闲线程执行，
如无则创建新线程执行，池中的空闲线程超过60秒， 将被销毁释放， 线程数随任务的多少变化，适用于耗时较小的异步任务，
池的核心线程数=0， 最大线程数=Integer.MAX_VALUE

newSingleThreadExecutor() :

只有一个线程来执行无界任务队列的单一线程池，该线程池确保任务按加入的顺序一个一个的依次执行，当唯一的线程因任务异常中止时，
将创建一个新的线程来继续执行后续的任务， 与newFixedThreadPool(1)的区别在于，单一线程池的池大小在newSingleThreadExecutor
方法中硬编码，不能再改变

newScheduledThreadPool(int corePoolSize) :

	能定时执行任务的线程池，该池的核心线程数由参数指定，最大线程数=Integer.MAX_VALUE

一 般不推荐直接使用Executors 直接创建线程，而是用 ThreadPoolExecutor类，上面的四个底层就是ThreadPoolExecutor。
说明：Executors返回的线程池对象的弊端如下：
1）FixedThreadPool和SingleThreadPool:允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
2）CachedThreadPool和ScheduledThreadPool:允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

3、ThreadPoolExcutor线程池参数详解

参数	说明
corePoolSize	核心线程数量，线程池维护线程的最少数量
maximumPoolSize	线程池维护线程的最大数量
keepAliveTime	线程池除核心线程外的其他线程的最长空闲时间，超过该时间的空闲线程会被销毁
unit	keepAliveTime的单位
workQueue	线程池所使用的任务缓冲队列
threadFactory	线程工厂，用于创建线程，一般用默认的即可
handler	线程池对拒绝任务的处理策略，AbortPolicy默认的处理方式

当线程池任务处理不过来的时候，我们就需要设定拒绝策略：
（1）ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常；也是默认的处理方式。
（2）ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。
（3）ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
（4）ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

4、线程池原理

（1）是否达到核心线程数量？没达到，创建一个工作线程来执行任务。
（2）工作队列是否已满？没满，则将新提交的任务存储在工作队列里。
（3）是否得到线程池最大数量？没达到，则创建一个新的工作线程来执行任务。
（4）最后，执行拒绝策略来处理这个任务

5、代码举例

线程池信息： 核心线程数量5，最大数量10，队列大小3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的

//测试： 提交15个执行时间需要3秒的任务,看线程池的状况
public void testCommon(ThreadPoolExecutor threadPoolExecutor) throws Exception {
        // 测试： 提交15个执行时间需要3秒的任务，看超过大小的2个，对应的处理情况
        for (int i = 0; i < 15; i++) {
            final int n = i;
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("开始执行：" + n);
                        Thread.sleep(3000L);
                        System.err.println("执行结束:" + n);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            System.out.println("任务提交成功 :" + i);
        }
        // 查看线程数量，查看队列等待数量
        Thread.sleep(500L);
        System.out.println("当前线程池线程数量为：" + threadPoolExecutor.getPoolSize());
        System.out.println("当前线程池等待的数量为：" + threadPoolExecutor.getQueue().size());
        // 等待15秒，查看线程数量和队列数量（理论上，会被超出核心线程数量的线程自动销毁）
        Thread.sleep(15000L);
        System.out.println("当前线程池线程数量为：" + threadPoolExecutor.getPoolSize());
        System.out.println("当前线程池等待的数量为：" + threadPoolExecutor.getQueue().size());
    }



    private void threadPoolExecutorTest2() throws Exception {
        // 创建一个 核心线程数量为5，最大数量为10,等待队列最大是3 的线程池，也就是最大容纳13个任务。
        // 默认的策略是抛出RejectedExecutionException异常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.err.println("有任务被拒绝执行了");
            }
        });
        testCommon(threadPoolExecutor);
        // 预计结果：
        // 1、 5个任务直接分配线程开始执行
        // 2、 3个任务进入等待队列
        // 3、 队列不够用，临时加开5个线程来执行任务(5秒没活干就销毁)
        // 4、 队列和线程池都满了，剩下2个任务，没资源了，被拒绝执行。
        // 5、 任务执行，15秒后，如果无任务可执行，销毁临时创建的5个线程
    }