一、简述

阿里开发手册关于多线程的一段描述：线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式。这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。Executors 返回的线程池对象的弊端如下：
1️⃣FixedThreadPool 和 SingleThreadPool允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。原因很简单：
newSingleThreadExecutor 和 newFixedThreadPool 在 workQueue 参数直接使用了new LinkedBlockingQueue<Runnable>() 无界队列理论上可以无限添加任务到线程池。如果提交到线程池的任务有问题，比如 sleep 永久，会造成内存泄漏，最终导致 OOM。同时阿里还推荐自定义 threadFactory 设置线程名称便于以后排查问题。
2️⃣CachedThreadPool 和 ScheduledThreadPool允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。底层队列直接提交队列 SynchronousQueue 和 DelayedWorkQueue。

二、原因

1️⃣FixedThreadPool 和 SingleThreadPool
这两个线程池大小是固定的。SingleThreadPool 是单个线程的线程池。FixedThreadPool 在应对平稳流量的时候，能有效的处理，缺点就是可能无法应付突发性大流量。使用 Executors 创建：

ExecutorService ftp = Executors.newFixedThreadPool(10);
ExecutorService ste = Executors.newSingleThreadExecutor();

源码如下：

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

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

两个方法，都通过 LinkedBlockingQueue<Runnable> 接收来不及处理的任务。关键点就在这个队列里，默认的构造器容量是 Integer.MAX_VALUE。

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

当流量突然变得非常大时，线程池满，等候队列变得非常庞大，内存和 CPU 都告急，这样无疑会对服务器造成非常大的压力。

2️⃣CachedThreadPool 和 ScheduledThreadPool

ExecutorService ctp = Executors.newCachedThreadPool();
ExecutorService stp = Executors.newScheduledThreadPool(10);

源码如下：

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

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
    }

public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

同理，从工厂方法可以看到，这两种线程池，线程池大小是不固定的，虽然 newScheduledThreadPool 传入一个线程数，但是这个数字只是核心线程数，可能还会扩容，直至 Integer.MAX_VALUE。而它们使用的队列是 SynchronousQueue 和 DelayedWorkQueue，初始化时不会像 LinkedBlockingQueue 那样一下子将容量调整到最大。

Java 线程的四种创建方式及五种状态