一、Executors创建线程池

1.newFixedThreadPool

先来看看源码中是怎么构造的：


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

核心线程数和最大线程数是一样的，且阻塞队列为LinkedBlockingQueue，最大长度为$2^{31}$-1=2147483647，可以看看它的构造方法：

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

public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    last = head = new Node<E>(null);
}

2.newSingleThreadExecutor

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

可以看出，与newFixedThreadPool类似，这里核心线程数和最大线程数均为1.
也很明显，如果用newFixedThreadPool、newSingleThreadExecutor，主要问题会出现在阻塞队列过长，堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。

3.newCachedThreadPool

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

4.newScheduledThreadPool

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

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

newCachedThreadPool、newScheduledThreadPool会出问题体现在最大核心线程数都是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。

二、ThreadPoolExcutor显示创建线程池

1.入参说明

先看看构造方法：

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

corePoolSize：核心线程数。线程池维护线程的最少数量。在没有任务执行时线程池的大小。（ps: 在创建ThreadPoolExecutor初期，线程并不会立即启动，而是等到有任务提交时才会启动，除非调用prestartAllCoreThreads）
maximumPoolSize：线程池维护线程的最大数量。
keepAliveTime：线程池维护线程所允许的空闲时间。只有当线程池的线程数 > corePoolSize 时，keepAliveTime 才会起作用。但当 ThreadPoolExecutor 的 allowCoreThreadTimeOut 变量设置为 true 时，核心线程超时后会被回收。
unit：线程池维护线程所允许的空闲时间的单位。
workQueue：阻塞队列。当当前线程数>corePoolSize，新进来的任务会放置在此。常见的有以下几种：
- ArrayBlockingQueue：是一个有边界的阻塞队列，它的内部实现是一个数组。它的容量在初始化时就确定不变。
- LinkedBlockingQueue：阻塞队列大小的配置是可选的，其内部实现是一个链表。
- PriorityBlockingQueue：是一个没有边界的队列，所有插入到PriorityBlockingQueue的对象必须实现java.lang.Comparable接口，队列优先级的排序就是按照我们对这个接口的实现来定义的。
- SynchronousQueue：队列内部仅允许容纳一个元素。当一个线程插入一个元素后会被阻塞，除非这个元素被另一个线程消费。
threadFactory：线程工厂，主要用来创建线程。
handler：当线程数达到最大时，新的任务的拒绝策略，包括:
- ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
- ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
- ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
- ThreadPoolExecutor.CallerRunsPolicy：只要线程池不关闭，该策略直接在调用者线程中，运行当前被丢弃的任务；
可以自定义实现RejectedExecutionHandler。