【Java面试进阶】谈谈为什么禁止使用Executors创建线程池？

首先， 可以通过Executors静态工厂构建线程池，但是一般不建议这样使用。

什么是Executors？

Executors是一个Java中的工具类。提供工厂方法来创建不同类型的线程池。如下所示：

从源码中可知，Executors的创建线程池的方法，创建出来的线程池都实现了ExecutorService接口。常用方法有以下几个：

• newFixedThreadPool(int nThreads)：创建固定数目线程的线程池。
• newCachedThreadPool()：创建一个可缓存的线程池，调用execute将重用以前构造的线程（如果线程可用）。如果没有可用的线程，则创建一个新线程并添加到线程池中。终止并从缓存中移除那些已有60秒钟未被使用的线程。
• newSingleThreadExecutor()：创建一个单线程化的Executor。
• newScheduledThreadPool(int corePoolSize)：创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。

从源码看，该类的功能还是非常强大的，而且还用到了工厂模式，具有比较强的扩展性，用起来也方便，例如：

ExecutorService executor = Executors.newFixedThreadPool(nThreads);

即可创建一个固定大小的线程池。

但是：在开发中不允许使用Executors去创建线程池，而是通过ThreadPoolExecutor的方式，这样可以避免资源耗尽的风险。原因是：

1. FixedThreadPool和SingleThreadPool：允许的请求队列长度为Integer.MAX_VALUE,可能会堆积大量的请求，从而导致OOM。
2. CachedThreadPool和ScheduledThreadPool：允许的创建线程数量为Integer.MAX_VALUE,可能会创建大量的线程，从而导致OOM。

Executors存在什么问题？

首先看一个简单的例子，模拟Executors导致OOM的情况：

package com.seckill.secondkill;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorsDemo {
    private static ExecutorService executor = Executors.newFixedThreadPool(15);

    public static void main(String[] args) {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            executor.execute(new SubThread());
        }
    }
}

class SubThread implements Runnable{

    @Override
    public void run() {
        try{
            Thread.sleep(10000);
        }catch (InterruptedException e){
            // do nothing
            e.printStackTrace();
        }
    }
}

指定JVM运行参数：-Xmx8m -Xms8m， 然后运行代码，会抛出OOM：

上面异常表示在main函数的线程中存在未捕获的异常。

Executors为什么存在缺陷？

我们分析newFixedThreadPool的底层源码，真正导致OOM的其实是LinkedBlockingQueue.offer方法：

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

这里补充Java中的阻塞队列的知识：
Java中的BlockingQueue主要有两种实现，分别是ArrayBlockingQueue和LinkedBlockingQueue。

• ArrayBlockingQueue是一个用数组实现的有界阻塞队列，必须设置容量。
• LinkedBlockingQueue是一个用链表实现的有界阻塞队列，容量可以选择进行设置，不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE.

因此，这里就出现了一个问题：如果我们不设置 LinkedBlockingQueue 的容量的话，其默认容量将会是 Integer.MAX_VALUE。而newFixedThreadPool中创建LinkedBlockingQueue时，并未指定容量。此时，LinkedBlockingQueue就是一个无边界队列，对于一个无边界队列来说，是可以不断的向队列中加入任务的，这种情况就有可能因为任务过多导致内存溢出问题。

上面提到的问题主要体现在 newFixedThreadPool 和 newSingleThreadExecutor 两个工厂方法上，并不是说 newCachedThreadPool 和 newScheduledThreadPool 这两个方法就安全了，这两种方式创建的最大线程数可能是 Integer.MAX_VALUE，而创建这么多线程，必然就有可能导致 OOM。

如何正确创建线程池？

避免使用Executors创建线程池，主要是避免使用其中的默认实现。我们可以自己直接调用ThreadPoolExecutor的构造函数来自己创建线程池，在创建的同时，给BlockQueue指定容量就可以。

private static ExecutorService executor = 
            new ThreadPoolExecutor(10,10,60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));

这种情况下，一旦提交的线程数超过当前可用线程数时，就会抛出java.util.concurrent.RejectedExecutionException，这是因为当前线程池使用的队列是有界队列，队列已经满了便无法继续处理新的请求。但是异常（Exception）总比错误好。

当然，除了自己定义ThreadPoolExecutor外，还可以使用一些开源类库，比如apache和guava等。这里推荐使用guava提供的ThreadFactoryBuilder来创建线程池。示例如下：

package com.seckill.secondkill;


import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.apache.tomcat.util.threads.ThreadPoolExecutor;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;


public class ExecutorsDemo {
    private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
            .setNameFormat("demo-pool-%d").build();
    
    private static ExecutorService pool = new ThreadPoolExecutor(5, 100,
            0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            pool.execute(new SubThread());
        }
        System.out.println("END");
    }
}

class SubThread implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getState() + "----------" + Thread.currentThread().getName());
    }
}

执行过程中的线程数：

通过上述方式创建线程时，不仅可以避免 OOM 的问题，还可以自定义线程名称，更加方便的出错的时候溯源。