（三）并发编程之线程池

为什么要使用线程池,优势是什么?

线程池做的工作主要是控制运行的线程的数量,处理过程中将任务加入队列,然后在线程创建后启动这些任务,如果线程超过了最大数量,超出的数量的线程排队等候,等其他线程执行完毕,再从队列中取出任务来执行.

他的主要特点为:

线程复用
控制最大并发数
管理线程.

第一:降低资源消耗.通过重复利用自己创建的线程降低线程创建和销毁造成的消耗.
第二: 提高响应速度.当任务到达时,任务可以不需要等到线程创建就能立即执行.
第三: 提高线程的可管理性.线程是稀缺资源,如果无限的创建,不仅会消耗资源,还会较低系统的稳定性,使用线程池可以进行统一分配,调优和监控.

架构实现:
Java中的线程池是通过Executor框架实现的，该框架中用到了Executor，Executors,ExecutorService，ThreadPoolExecutor这几个类。

其中Executors顾名思义，和Collections相似，是一个工具类。
Executor框架的最顶层实现是ThreadPoolExecutor类，Executors工厂类中提供的newScheduledThreadPool、newFixedThreadPool、newCachedThreadPool方法其实也只是ThreadPoolExecutor的构造函数参数不同而已。通过传入不同的参数，就可以构造出适用于不同应用场景下的线程池，那么它的底层原理是怎样实现的呢，这篇就来介绍下ThreadPoolExecutor线程池的运行过程。

线程池四种创建方式

Java通过Executors（jdk1.5并发包）提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

重点看其中三个：

Executors.newFixedThreadPool(int)

主要特点如下:
1.创建一个定长线程池,可控制线程的最大并发数,超出的线程会在队列中等待.
2.newFixedThreadPool创建的线程池corePoolSize和MaxmumPoolSize是相等的,它使用的是 LinkedBlockingQueue，其中阻塞队列长度最大值为Integer.MAX_VALUE
Executors.newSingleThreadExecutor()
主要特点如下:

1.创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务都按照指定顺序执行.
2.newSingleThreadExecutor将corePoolSize和MaxmumPoolSize都设置为1,它使用的的LinkedBlockingQueue
Executors.newCachedThreadPool()
主要特点如下:
1.创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则创建新线程.
2.newCachedThreadPool将corePoolSize设置为0，MaximumPoolSize设置为Integer.MAX_VALUE,它使用的是SynchronousQUeue,也就是说来了任务就创建线程运行,如果线程空闲超过60秒,就销毁线程

从上面可以看出，其实三个线程池都调用了ThreadPoolExecutor来进行创建线程池，那么ThreadPoolExecutor底层究竟是什么？

ThreadPoolExecutor的七个参数

点击上面调用的ThreadPoolExecutor的构造函数，可以跳到ThreaPoolExecutor.java 类

直接点开this，查看七个参数的版本

从图中可以看出，ThreadPoolExecutor有7个参数，那么这七个参数到底代表什么意思呢？

corePoolSize: 线程池中的常驻核心线程数。
（1）在创建了线程池后,当有请求任务来之后,就会安排池中的线程去执行请求任务,近似理解为今日当值线程
（2）当线程池中的线程数目达到corePoolSize后,就会把到达的任务放入到缓存队列当中.
maximumPoolSize: 线程池能够容纳同时执行的最大线程数,此值大于等于1
keepAliveTime: 多余的空闲线程存活时间,当空间时间达到keepAliveTime 值时,多余的线程会被销毁直到只剩下corePoolSize 个线程为止。
（1）默认情况下:只有当线程池中的线程数大于corePoolSize时keepAliveTime才会起作用,直到线程中的线程数不大于 corepoolSIze。
unit:keepAliveTime的单位。
workQueue:任务队列,被提交但尚未被执行的任务。
threadFactory:表示生成线程池中工作线程的线程工厂,用户创建新线程,一般用默认即可。
handler:拒绝策略,表示当线程队列满了并且工作线程大于等于线程池的最大显示数(maxnumPoolSize)时如何来拒绝。

线程池底层的工作原理

以下重要!!!

线程池的拒绝策略

等待队列 也已经排满了，再也塞不下新的任务了，同时，线程池的maximumPoolSize 也到达了,无法接续为新任务服务
这时我们需要拒绝策略机制合理的处理这个问题。
JDK内置的拒绝策略有四个，分别是

AbortPolicy(默认):直接抛出RejectedException异常阻止系统正常运行。
CallerRunPolicy:"调用者运行"一种调节机制,该策略既不会抛弃任务,也不会抛出异常,而是该任务被线程池拒绝，由调用execute方法的线程执行该任务。
DiscardOldestPolicy:抛弃队列中等待最久的任务,然后把当前任务加入队列中尝试再次提交。
DiscardPolicy:直接丢弃任务,不予任何处理也不抛出异常.如果允许任务丢失,这是最好的拒绝策略。

以上内置策略均实现了RejectExecutionHandler 接口

线程池的使用和生产上合理设置参数

线程池用哪个？
上面了解到，Executors提供了一些创建线程池方法，单一的/固定数的/可变你的三种创建线程池的方法,用哪个呢？答案是一个都不用,我们生产上只能使用自定义的。
Executors中JDK给你提供了为什么不用?
javaExecutorsThreadPoolExecutorExecutors

FixedThreadPoolSingleThreadPool:Integer.MAX_VALUEOOM
CachedThreadPoolScheduledThreadPool:Integer.MAX_VALUEOOM

线程池是如何使用的？

public class MyThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                1L,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<Runnable>(3),
                Executors.defaultThreadFactory(),
                //默认抛出异常
                //new ThreadPoolExecutor.AbortPolicy()
                //回退调用者
                //new ThreadPoolExecutor.CallerRunsPolicy()
                //处理不来的不处理
                //new ThreadPoolExecutor.DiscardOldestPolicy()
                new ThreadPoolExecutor.DiscardPolicy()
        );
        //模拟10个用户来办理业务 没有用户就是来自外部的请求线程.
        try {
            for (int i = 1; i <= 10; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "\t 办理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
        //threadPoolInit();
    }

    private static void threadPoolInit() {
        /** * 一池5个处理线程 */
        //ExecutorService threadPool= Executors.newFixedThreadPool(5);
        /** * 一池一线程 */
        //ExecutorService threadPool= Executors.newSingleThreadExecutor();
        /** * 一池N线程 */
        ExecutorService threadPool = Executors.newCachedThreadPool();
        //模拟10个用户来办理业务 没有用户就是来自外部的请求线程.
        try {
            for (int i = 1; i <= 20; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "\t 办理业务");
                });
                try {
                    TimeUnit.MICROSECONDS.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
}