为什么阿里巴巴禁止使用 Executors 创建线程池？

点击上方 程序IT圈，选择 设为星标

优质文章，每日送达

阿里巴巴开发手册关于线程池有这样一条规定：

线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

一、线程池原理

1.1 为什么使用线程池

池化技术的思想主要是为了减少在创建和销毁线程上所消耗的时间及系统资源的开销，解决资源不足的问题。

1.2 线程池是如何实现的

本文只讨论通过ThreadPoolExecutor创建的线程池。ThreadPoolExecutor的构造器代码如下，里面涉及到的主要参数有corePoolSize，maximumPoolSize，keepAliveTime，unit，workQueue，threadFactory，handler。

public ThreadPoolExecutor(int corePoolSize, 
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

这些参数的含义为：

1. corePoolSize：核心线程数

2. maximumPoolSize：最大线程数

3. keepAliveTime：当线程池线程数量大于corePoolSize时候，多出来的空闲线程的存活时间

4. unit：参数keepAliveTime的时间单位，TimeUnit枚举类有天，小时，分，秒，毫秒，微秒，纳秒7种可以选择。

5. workQueue：线程池使用的缓冲队列，可供选择的有以下几种。

参数	描述
ArrayBlockingQueue	一个由数组结构组成的有界阻塞队列。
LinkedBlockingQueue	一个由链表结构组成的有界阻塞队列。常用
SynchronousQueue	一个不存储元素的阻塞队列，即直接提交给线程不保持它们。常用
PriorityBlockingQueue	一个支持优先级排序的无界阻塞队列。
DelayQueue	一个使用优先级队列实现的无界阻塞队列，只有在延迟期满时才能从中提取元素。
LinkedTransferQueue	一个由链表结构组成的无界阻塞队列。与SynchronousQueue类似，还含有非阻塞方法。
LinkedBlockingDeque	一个由链表结构组成的双向阻塞队列。

1. threadFactory：线程工厂，主要用来创建线程

2. handler：拒绝策略，拒绝处理任务时的策略，可供选择的有以下几种。

参数	描述
AbortPolicy	拒绝并抛出异常。默认的
CallerRunsPolicy	重试提交当前的任务，即再次调用运行该任务的execute()方法。
DiscardOldestPolicy	抛弃队列头部（最旧）的一个任务，并执行当前任务。
DiscardPolicy	抛弃当前任务。

1.3 线程池执行规则

1. 执行任务时，如果线程池中的线程数量小于corePoolSize，即使池中有空闲的线程数，也会创建新的线程来执行任务。

2. 线程池中的线程数量等于corePoolSize，并且缓冲队列未满时，则任务被放入缓冲队列中

3. 线程池中的线程数量大于等于corePoolSize，并且缓冲队列已满，同时线程数量小于maximumPoolSize，则会创建新的线程来执行任务。

4. 线程池中的线程数量已满时，则执行拒绝策略处理这些任务。

二、阿里巴巴手册为什么禁止用Exectors创建线程池

Exectors提供了几种工厂方法用来创建线程池，其中newCachedThreadPool()，newFixedThreadPool()，newSingleThreadExecutor()三种方法最终是通过实现类ThreadPoolExecutor来创建的。接下来一起看看这三种方法到底有什么问题，为什么阿里巴巴会禁止使用Exectors来创建线程池！

2.1 FixedThreadPool 解析

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

具体参数如下：

• corePoolSize：nThreads

• maximumPoolSize：nThreads

• keepAliveTime：0L

• unit：毫秒

• workQueue：LinkedBlockingQueue，一个由链表结构组成的有界阻塞队列，并且使用了最大长度的队列。

public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}

这种方式创建的线程池由于核心线程数和最大线程数相同，所以线程池中线程的数量是固定的，并且没有限制队列大小，所以多余的任务均会被放到队列中排队，在资源有限时容易出现内存溢出。

2.2 SingleThreadPool 解析

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

具体参数如下：

• corePoolSize：1

• maximumPoolSize：1

• keepAliveTime：0L

• unit：毫秒

• workQueue：LinkedBlockingQueue，一个由链表结构组成的有界阻塞队列，并且使用了最大长度的队列。

public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}

这种方式创建的线程池是单线程线程池，核心线程数和最大线程数都是1，多余的任务都将会被放到缓冲队列中去，所以在资源优先的情况下容易出现内存溢出。

2.3 CachedThreadPool 解析

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

具体参数如下：

• corePoolSize：0

• maximumPoolSize：Integer.MAX_VALUE

• keepAliveTime：60L

• unit：秒

• workQueue：SynchronousQueue，一个不存储元素的阻塞队列，即直接提交给线程不保持它们。

这种方式创建的线程池核心线程数为0，并且使用了SynchronousQueue队列，这个队列不存储元素，也就是任务直接会直接通过创建非核心线程来执行，核心线程数为Integer.MAX_VALUE，可以任务能无限创建队列，因此在资源优先的情况下容易发生内存溢出。

2.4 测试OOM异常

既然我们已经分析了三种创建线程池可能会出现OOM异常，那么我们测试一下到底会不会发生OOM呢？这里我将选择newSingleThreadExecutor()来进行测试，其他两个方法测试流程也是一样的。为了尽快出现OOM，我们将JVM的内存调小一点。

• -Xmx5M ：最大内存值5M

• -Xms5M：初始内存大小5M

测试代码

public static void main(String[] args) {

    ExecutorService service = Executors.newSingleThreadExecutor();
    while (true){
        service.execute(() -> {
            System.out.println("我是一个任务，运行时间："+System.currentTimeMillis()+"\n");
        });
    }
}

测试结果

任务跑了1分钟左右，就发生了OOM异常

三、总结

阿里巴巴开发手册为什么禁止使用 Executors 去创建线程池，原因就是 newFixedThreadPool() 和 newSingleThreadExecutor()两个方法允许请求的最大队列长度是 Integer.MAX_VALUE ，可能会出现任务堆积，出现OOM。newCachedThreadPool()允许创建的线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，导致发生OOM。它建议使用ThreadPoolExecutor方式去创建线程池，通过上面的分析我们也知道了其实Executors 三种创建线程池的方式最终就是通过ThreadPoolExecutor来创建的，只不过有些参数我们无法控制，如果通过ThreadPoolExecutor的构造器去创建，我们就可以根据实际需求控制线程池需要的任何参数，避免发生OOM异常。

< END >

往期精选：

10张图让你彻底理解回调函数

MySQL大表优化方案

Redis 为什么默认 16 个数据库？

在这里获得的不仅仅是技术！

喜欢就给个“在看”