关于为何推荐使用自定义线程池 浅谈

　　看过阿里巴巴开发手册并发编程这块的朋友都会知道有这么一句话：【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样

的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。并且在代码扫描中也会有相应提示。

 

 

 我们常用的创建线程池的方式本质是返回ThreadPoolExecutor 对象。

ThreadPoolExecutor 对象

　　ThreadPoolExecutor的API定义如下：

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

构造函数参数说明：

• corePoolSize => 线程池核心线程数量
• maximumPoolSize => 线程池最大数量
• keepAliveTime => 空闲线程存活时间
• unit => 时间单位
• workQueue => 线程池所使用的缓冲队列
• threadFactory => 线程池创建线程使用的工厂
• handler => 线程池对拒绝任务的处理策略，如果需要自定义RejectedExecutionHandler接口即可

 

在JUC中 Executors创建返回 ThreadPoolExecutor 对象的方法共有三种：

• Executors#newCachedThreadPool => 创建可缓存的线程池

• Executors#newSingleThreadExecutor => 创建单线程的线程池

• Executors#newFixedThreadPool => 创建固定长度的线程池

java中线程池通用流程：

1. 判断核心线程数是否已满，核心线程数大小和corePoolSize参数有关，未满则创建线程执行任务

2. 若核心线程池已满，判断队列是否满，队列是否满和workQueue参数有关，若未满则加入队列中

3. 若队列已满，判断线程池是否已满，线程池是否已满和maximumPoolSize参数有关，若未满创建线程执行任务

4. 若线程池已满，则采用拒绝策略处理无法执执行的任务，拒绝策略和handler参数有关

详解创建返回ThreadPoolExecutor的是那种方式

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，线程池最大数量为 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，线程池最大数量为 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 => nThreads，核心线程池的数量为 1

• maximumPoolSize => nThreads，线程池最大数量为 nThreads，即最多只可以创建 nThreads 个线程

• keepAliveTime => 0L

• unit => 毫秒

• workQueue => LinkedBlockingQueue 它和SingleThreadExecutor类似，唯一的区别就是核心线程数不同，并且由于「使用的是LinkedBlockingQueue，在资源有限的时候容易引起OOM异常」

总结：

• FixedThreadPool 和 SingleThreadExecutor => 允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而引起OOM异常

• CachedThreadPool => 允许创建的线程数为 Integer.MAX_VALUE，可能会创建大量的线程，从而引起OOM异常

• 并且三则的拒绝策略都是默认策略，抛出异常RejectedExecutionException，源码如下，在很多特定业务场景都不发满足

   private static final RejectedExecutionHandler defaultHandler =
          new AbortPolicy();
  
  

  public static class AbortPolicy implements RejectedExecutionHandler {
      /**
       * Creates an {@code AbortPolicy}.
       */
      public AbortPolicy() { }
  
      /**
       * Always throws RejectedExecutionException.
       *
       * @param r the runnable task requested to be executed
       * @param e the executor attempting to execute this task
       * @throws RejectedExecutionException always
       */
      public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
          throw new RejectedExecutionException("Task " + r.toString() +
                                               " rejected from " +
                                               e.toString());
      }
  }