引言：更多相关请看 JAVA并发编程系列

线程池优势

线程池做的工作主要是控制运行的线程的数量，处理过程中将任务加入队列，然后在线程创建后启动这些任务，如果先生超过了最大数量，超出的数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。
主要特点为：线程复用；控制最大并发数；管理线程。
第一：降低资源消耗。通过重复利用自己创建的线程降低线程创建和销毁造成的消耗。
第二：提高响应速度。当任务到达时，任务可以不需要等到线程和粗昂就爱你就能立即执行。
第三：提高线程的可管理性。线程是稀缺资源，如果无限的创阿金，不仅会消耗资源，还会较低系统的稳定性，使用线程池可以进行统一分配，调优和监控。

线程池使用

架构实现

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

实现方法

了解：Executors。newCachedThreadPool()；Java8新出Executors。newWorkStealingPool(int);(java8新增，使用目前机器上可以的处理器作为他的并行级别) 重点
ThreadPoolExecutor

Executors.newFixedThreadPool(int)

主要特点如下: 1.创建一个定长线程池，可控制线程的最大并发数，超出的线程会在队列中等待。
2.newFixedThreadPool创建的线程池corePoolSize和MaxmumPoolSize是相等的，它使用的的LinkedBlockingQueue。执行一个长期的任务，性能好很多。

Executors.newSingleThreadExecutor()

主要特点如下:
1.创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务都按照指定顺序执行。 2.newSingleThreadExecutor将corePoolSize和MaxmumPoolSize都设置为1，它使用的是LinkedBlockingQueue。适用于一个任务一个线程执行的任务场景。

Executors.newCachedThreadPool()

主要特点如下:
1.创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则创建新线程。
2.newCachedThreadPool将corePoolSize设置为0，MaxmumPoolSize设置为Integer.MAX_VALUE，它使用的是SynchronousQueue，也就是说来了任务就创建线程运行，如果线程空闲超过60秒，就销毁线程。适用:执行很多短期异步的小程序或者负载较轻的服务器。

案例演示

class Test {

    public static void main(String[] args) {
//        线程池创建线程
//        ExecutorService threadPool = Executors.newFixedThreadPool(5);//一池五个线程
        /*
        执行效果：最多不超过5个窗口
        pool-1-thread-1	办理业务
        pool-1-thread-5	办理业务
        pool-1-thread-1	办理业务
        pool-1-thread-4	办理业务
        pool-1-thread-3	办理业务
        pool-1-thread-4	办理业务
        pool-1-thread-2	办理业务
        pool-1-thread-3	办理业务
        pool-1-thread-1	办理业务
        pool-1-thread-5	办理业务
        * */
//        ExecutorService threadPool = Executors.newSingleThreadExecutor();//一池1个线程
        /*
        执行效果：最多不超过1个窗口
        pool-1-thread-1	办理业务
        pool-1-thread-1	办理业务
        pool-1-thread-1	办理业务
        pool-1-thread-1	办理业务
        pool-1-thread-1	办理业务
        pool-1-thread-1	办理业务
        pool-1-thread-1	办理业务
        pool-1-thread-1	办理业务
        pool-1-thread-1	办理业务
        pool-1-thread-1	办理业务
         */
        ExecutorService threadPool = Executors.newCachedThreadPool();//一池N个线程，不固定
        /*
        执行效果：有10个窗口
        pool-1-thread-2	办理业务
        pool-1-thread-1	办理业务
        pool-1-thread-8	办理业务
        pool-1-thread-4	办理业务
        pool-1-thread-3	办理业务
        pool-1-thread-5	办理业务
        pool-1-thread-7	办理业务
        pool-1-thread-6	办理业务
        pool-1-thread-9	办理业务
        pool-1-thread-10	办理业务
         */

        try {
            // 模拟10个用户办理业务
            for (int i = 1; i <= 10; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "\t办理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
    
}

线程池7大参数

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

参数详解

手写看下面一段自定义代码。

new ThreadPoolExecutor(5, 10,
	100, TimeUnit.MILLISECONDS,
	new ArrayBlockingQueue<>(3), Executors.defaultThreadFactory(),
	new ThreadPoolExecutor.AbortPolicy());

如果把多线程比作一个餐馆：
1、核心线程数类似餐位，只允许最多5位客人用餐。
2、当来用餐的客人大于5时，客人会去任务队列（等候区）等待，候客区的等待位置为3。
3、当就餐区的位置5和候客区的位置3（等于8）都满了时，客人太多了，需要增加就餐区的位置数量，这时需要调用线程工厂去扩容就餐区位置。马上打电话给休假的人，今天客人太多，快来加班吧！
4、但是记住，就餐区的最大容量不能超过10（最大线程数）。
5、如果就餐区位置扩容为最大容量10且客人[线程]也满，加上候客区也满（执行线程10，工作队列的线程3）。再来客人时会执行拒绝策略，AbortPolicy是直接直接，告诉后面来的客人说：不好意思，今天本店爆满，请去其它地方就餐。
6、如果过了一会，客人比较少，就餐区位置空闲着，空闲超过一定时间（空闲时间由keepAliveTime和unit决定），会把大于等于核心线程5的空闲线程全部撤走，直至剩下核心线程数量为止。

线程池底层工作原理

1.在创建了线程池后，等待提交过来的任务请求。
2.当调用 execute()方法添加一个请求任务时，线程池会做如下判断：
2.1如果正在运行的线程数量小于core PoolSize，那么马上创建线程运行这个任务；
2.2如果正在运行的线程数量大于或于 core PoolSize,那么将这个任务放入队；
2.3如果这时候队列满了且正在运行的线程数量还小于 maximumPoolSize，那么还是要创建非核心线程立刻运行这个任。
2.4如果队列满了且正在运行的线程数量大于或等于maximumPoolsize,那么线程池会启动饱和拒绝策略来执行。
3.当一个线程完成任务时，它会从队列中取下一个任务来执行。
4.当一个线程无事可做超过一定的时间( keepAliveTime)时，线程池会判断：如果当前运行的线程数大于corePoolsize,那么这个线程就被停掉。

线程池拒绝策略

概述：等待队列也已经排满了，再也塞不下新的任务了。同时，线程池的max也到达了，无法接续为新任务服务这时需要拒绝策略机制合理的处理这个问题。
JDK内置的拒绝策略：
AbortPolicy(默认):直接抛出RejectedException异常阻止系统正常运行。
CallerRunPolicy:"调用者运行"一种调节机制，该策略既不会抛弃任务，也不会抛出异常。
DiscardOldestPolicy:抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交。
DiscardPolicy:直接丢弃任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的拒绝策略。
以上内置策略均实现了RejectExecutionHandler接口。

其它

你在工作中单一的/固定数的/可变你的三种创建线程池的方法,你用哪个多?

答案是一个都不用,我们生产上只能使用自定义的。Executors中JDK给你提供了为什么不用?参考阿里巴巴java开发手册。
【强制】线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。说明：使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源的开销，解决资源不足的问题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。
【强制】线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。说明：Executors返回的线程池对象的弊端如下：
1）FixedThreadPool和SingleThreadPool:允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
2）CachedThreadPool和ScheduledThreadPool:允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

工作中自定义过线程池使用

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();
        }
    }
}

合理配置线程池

CPU密集型

System.out.println(Runtime.getRuntime().availableProcessors());查看CPU核数。
CPU密集的意思是该任务需要大量的运算，而没有阻寒，CPU一直全速运行。cPU密集任务只有在真正的多核CPU上才可能得到加速(通过多线程)，而在单核CPU上，无论你开几个模拟的多线程该任务都不可能得到加速，因为CPU总的运算能力就那些。CPU密集型任务配置尽可能少的线程数量。
一般公式：CPU核数+1个线程的线程池。

IO密集型

由于IO密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如cpu核数。IO密集型，即该任务需要大量的10，即大量的阻塞。在单线程上运行IO密集型的任务会导致浪费大量的cpu运算能力浪费在等待。所以在IO密集型任务中使用多线程可以大大的加速程序运行，即使在单核cpu上，这种加速主要就是利用了被浪费掉的照塞时间.IO密集型时，大部分线程都阻寒，故需要多配置线程数：
参考公式：cpu核数/(1-阻寒系数)。
阳寒系数在0.8-0.9之间比如8核cpu：8/(1-0.9) = 0个线程数。

线程池ThreadPoolExecutor