【多线程】ThreadPoolExcutor线程池

一、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，新进来的任务会放置在此。常见的有以下几种：
  (1) ArrayBlockingQueue是一个有边界的阻塞队列，它的内部实现是一个数组。它的容量在初始化时就确定不变。
  (2) LinkedBlockingQueue：阻塞队列大小的配置是可选的，其内部实现是一个链表。
  (3) PriorityBlockingQueue：是一个没有边界的队列，所有插入到PriorityBlockingQueue的对象必须实现java.lang.Comparable接口，队列优先级的排序就是按照我们对这个接口的实现来定义的。
  (4) SynchronousQueue队列内部仅允许容纳一个元素。当一个线程插入一个元素后会被阻塞，除非这个元素被另一个线程消费。
• threadFactory：线程工厂，主要用来创建线程。
• handler：当线程数达到最大时，新的任务的拒绝策略，包括:
  (1) ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
  (2) ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
  (3) ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
  (4) ThreadPoolExecutor.CallerRunsPolicy：只要线程池不关闭，该策略直接在调用者线程中，运行当前被丢弃的任务；
  可以自定义实现RejectedExecutionHandler。

2.内部执行流程

1.线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。
2.当调用execute()方法添加一个任务时，线程池会做如下判断：
a.如果正在运行的线程数小于corePoolSize，那么马上创建线程运行这个任务。
b.如果正在运行的线程数大于或者等于corePoolSize,那么将这个任务放入队列。
c.如果这个时候队列满了，而且正在运行的线程数量小于maximumPoolSize,那么还是要创建线程运行这个任务。
d.如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，通过 handler所指定的策略来处理此任务。
3.当一个线程完成任务时，它会从队列中取下一个任务来执行。
4.当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运行的线程数大于corePoolSize时，那么这个线程会被停用掉，所以线程池的所有任务完成后，它最终会收缩到corePoolSize的大小。