为何阿里巴巴要禁用Executors建立线程池？

看阿里巴巴开发手册并发编程这块有一条：线程池不容许使用Executors去建立，而是经过ThreadPoolExecutor的方式，经过源码分析禁用的缘由

线程池的定义

管理一组工做线程。经过线程池复用线程有如下几点优势：

• 减小资源建立 => 减小内存开销，建立线程占用内存
• 下降系统开销 => 建立线程须要时间，会延迟处理的请求
• 提升稳定稳定性 => 避免无限建立线程引发的OutOfMemoryError【简称OOM】

Executors建立线程池的方式

根据返回的对象类型建立线程池能够分为三类：

• 建立返回ThreadPoolExecutor对象
• 建立返回ScheduleThreadPoolExecutor对象
• 建立返回ForkJoinPool对象

本文只讨论建立返回ThreadPoolExecutor对象

ThreadPoolExecutor对象

在介绍Executors建立线程池方法前先介绍一下ThreadPoolExecutor，由于这些建立线程池的静态方法都是返回ThreadPoolExecutor对象，和咱们手动建立ThreadPoolExecutor对象的区别就是咱们不须要本身传构造函数的参数。ThreadPoolExecutor的构造函数共有四个，但最终调用的都是同一个：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

构造函数参数说明：

• corePoolSize => 线程池核心线程数量
• maximumPoolSize => 线程池最大数量
• keepAliveTime => 空闲线程存活时间
• unit => 时间单位
• workQueue => 线程池所使用的缓冲队列
• threadFactory => 线程池建立线程使用的工厂
• handler => 线程池对拒绝任务的处理策略

线程池执行任务逻辑和线程池参数的关系

执行逻辑说明：

• 判断核心线程数是否已满，核心线程数大小和corePoolSize参数有关，未满则建立线程执行任务
• 若核心线程池已满，判断队列是否满，队列是否满和workQueue参数有关，若未满则加入队列中
• 若队列已满，判断线程池是否已满，线程池是否已满和maximumPoolSize参数有关，若未满建立线程执行任务
• 若线程池已满，则采用拒绝策略处理没法执执行的任务，拒绝策略和handler参数有关

Executors建立返回ThreadPoolExecutor对象

Executors建立返回ThreadPoolExecutor对象的方法共有三种：

• Executors#newCachedThreadPool => 建立可缓存的线程池
• Executors#newSingleThreadExecutor => 建立单线程的线程池
• Executors#newFixedThreadPool => 建立固定长度的线程池

Executors#newCachedThreadPool方法

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

CachedThreadPool是一个根据须要建立新线程的线程池

• corePoolSize => 0，核心线程池的数量为0
• maximumPoolSize => Integer.MAX_VALUE，能够认为最大线程数是无限的
• keepAliveTime => 60L
• unit => 秒
• workQueue => SynchronousQueue

当一个任务提交时，corePoolSize为0不建立核心线程，SynchronousQueue是一个不存储元素的队列，能够理解为队里永远是满的，所以最终会建立非核心线程来执行任务。对于非核心线程空闲60s时将被回收。由于Integer.MAX_VALUE很是大，能够认为是能够无限建立线程的，在资源有限的状况下容易引发OOM异常

Executors#newSingleThreadExecutor方法

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

SingleThreadExecutor是单线程线程池，只有一个核心线程

• corePoolSize => 1，核心线程池的数量为1
• maximumPoolSize => 1，只能够建立一个非核心线程
• keepAliveTime => 0L
• unit => 秒
• workQueue => LinkedBlockingQueue

当一个任务提交时，首先会建立一个核心线程来执行任务，若是超过核心线程的数量，将会放入队列中，由于LinkedBlockingQueue是长度为Integer.MAX_VALUE的队列，能够认为是无界队列，所以往队列中能够插入无限多的任务，在资源有限的时候容易引发OOM异常，同时由于无界队列，maximumPoolSize和keepAliveTime参数将无效，压根就不会建立非核心线程

Executors#newFixedThreadPool方法

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

FixedThreadPool是固定核心线程的线程池，固定核心线程数由用户传入

• corePoolSize => 1，核心线程池的数量为1
• maximumPoolSize => 1，只能够建立一个非核心线程
• keepAliveTime => 0L
• unit => 秒
• workQueue => LinkedBlockingQueue

它和SingleThreadExecutor相似，惟一的区别就是核心线程数不一样，而且因为使用的是LinkedBlockingQueue，在资源有限的时候容易引发OOM异常

总结：

• FixedThreadPool和SingleThreadExecutor => 容许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而引发OOM异常
• CachedThreadPool => 容许建立的线程数为Integer.MAX_VALUE，可能会建立大量的线程，从而引发OOM异常

这就是为何禁止使用Executors去建立线程池，而是推荐本身去建立ThreadPoolExecutor的缘由

OOM异常测试

理论上会出现OOM异常，必须测试一波验证以前的说法：
测试类：TaskTest.java

public class TaskTest {
    public static void main(String[] args) {
        ExecutorService es = Executors.newCachedThreadPool();
        int i = 0;
        while (true) {
            es.submit(new Task(i++));
        }
    }
}

使用Executors建立的CachedThreadPool，往线程池中无限添加线程
在启动测试类以前先将JVM内存调整小一点，否则很容易将电脑跑出问题【别问我为何知道，是铁憨憨甜没错了！！！】，在idea里：Run -> Edit Configurations

JVM参数说明：

• -Xms10M => Java Heap内存初始化值
• -Xmx10M => Java Heap内存最大值

运行结果：

Exception: java.lang.OutOfMemoryError thrown from the UncaughtExceptionHandler in thread "main"
Disconnected from the target VM, address: '127.0.0.1:60416', transport: 'socket'

建立到3w多个线程的时候开始报OOM错误
另外两个线程池就不作测试了，测试方法一致，只是建立的线程池不同

如何定义线程池参数

• CPU密集型 => 线程池的大小推荐为CPU数量 + 1，CPU数量能够根据Runtime.availableProcessors方法获取
• IO密集型 => CPU数量 CPU利用率 (1 + 线程等待时间/线程CPU时间)
• 混合型 => 将任务分为CPU密集型和IO密集型，而后分别使用不一样的线程池去处理，从而使每一个线程池能够根据各自的工做负载来调整
• 阻塞队列 => 推荐使用有界队列，有界队列有助于避免资源耗尽的状况发生

• 拒绝策略 => 默认采用的是AbortPolicy拒绝策略，直接在程序中抛出RejectedExecutionException异常【由于是运行时异常，不强制catch】，这种处理方式不够优雅。处理拒绝策略有如下几种比较推荐：

  • 在程序中捕获RejectedExecutionException异常，在捕获异常中对任务进行处理。针对默认拒绝策略
  • 使用CallerRunsPolicy拒绝策略，该策略会将任务交给调用execute的线程执行【通常为主线程】，此时主线程将在一段时间内不能提交任何任务，从而使工做线程处理正在执行的任务。此时提交的线程将被保存在TCP队列中，TCP队列满将会影响客户端，这是一种平缓的性能下降
  • 自定义拒绝策略，只须要实现RejectedExecutionHandler接口便可
  • 若是任务不是特别重要，使用DiscardPolicy和DiscardOldestPolicy拒绝策略将任务丢弃也是能够的

若是使用Executors的静态方法建立ThreadPoolExecutor对象，能够经过使用Semaphore对任务的执行进行限流也能够避免出现OOM异常
因为线程池参数定义经验较少，都是理论知识，欢迎有经验的大佬补充

天天学习一点点，加油呀，欢迎点赞

附往期文章：欢迎你的阅读、点赞、评论

设计模式相关：
1. 单例模式，你真的写对了吗？
2. (策略模式+工厂模式+map)套餐 Kill 项目中的switch case

JAVA8相关：
1. 使用Stream API优化代码
2. 亲，建议你使用LocalDateTime而不是Date哦

数据库相关：
1. mysql数据库时间类型datetime、bigint、timestamp的查询效率比较
2. 很高兴！终于踩到了慢查询的坑

高效相关：
1. 撸一个Java脚手架，一统团队项目结构风格

日志相关：
1. 日志框架，选择Logback Or Log4j2？
2. Logback配置文件这么写，TPS提升10倍

工程相关：
1. 闲来无事，动手写一个LRU本地缓存
2. Redis实现点赞功能模块
3. JMX可视化监控线程池
4. 权限管理 【SpringSecurity篇】
5. Spring自定义注解从入门到精通
6. java模拟登录优酷
7. QPS这么高，那就来写个多级缓存吧
8. java使用phantomjs进行截图

其余：
1. 使用try-with-resources优雅关闭资源
2. 老板，用float存储金额为何要扣我工资