https://www.jianshu.com/p/13e5dcaa9ba5

1. 四种线程池

1.1 NewCachedThreadPool
创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
适用：执行很多短期的任务

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

1.2 NewFixedThreadPool
创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
适用：执行长期运行任务

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

1.3 NewSingleThreadExecutor
创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序（FIFO、LIFO、优先级）执行。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
适用：一个任务一个任务的执行场景

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

1.4 NewScheduledThreadPool
创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
适用：周期性执行任务的场景

  1. public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
  2.         return new ScheduledThreadPoolExecutor(corePoolSize);
  3. }
  4. public ScheduledThreadPoolExecutor(int corePoolSize) {
  5.         super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
  6.               new DelayedWorkQueue());
  7. }
  8. // super()
  9. public ThreadPoolExecutor(int corePoolSize,
  10.                               int maximumPoolSize,
  11.                               long keepAliveTime,
  12.                               TimeUnit unit,
  13.                               BlockingQueue<Runnable> workQueue) {
  14.         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
  15.              Executors.defaultThreadFactory(), defaultHandler);
  16.  }

2. Java 线程池底层调用是什么？

2.1 以上这几种线程池，都是调用的ThreadPoolExecutor类；而ThreadPoolExecutor类是ExecutorService接口的默认实现之一。
2.2 构造方法：

  1. public ThreadPoolExecutor(int corePoolSize,
  2.                               int maximumPoolSize,
  3.                               long keepAliveTime,
  4.                               TimeUnit unit,
  5.                               BlockingQueue<Runnable> workQueue,
  6.                               ThreadFactory threadFactory) {
  7.         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
  8.              threadFactory, defaultHandler);
  9. }

2.3 构造方法参数定义：
corePoolSize：线程池中核心线程数的最大值
maximumPoolSize：线程池中能拥有最多线程数
keepAliveTime：线程存活时间,表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize
unit：时间单位
workQueue：用于缓存任务的阻塞队列
threadFactory：线程工厂，主要用来创建线程；
defaultHandler：表示当拒绝处理任务时的策略
2.4 corePoolSize、maximumPoolSize、workQueue三者之间的关系：
A.如果没有空闲的线程执行该任务并且当前运行线程数小于corePoolSize，则添加新的线程执行该任务。
B.如果没有空闲的线程执行该任务并且当前运行线程数等于corePoolSize，同时阻塞队列未满，则将任务入队，而不添加新的线程。
C.如果没有空闲的线程执行该任务且阻塞队列已满同时线程池中的线程数小于maximumPoolSize，则创建此线程执行任务。
D.如果没有空闲的线程执行该任务且阻塞队列已满同线程池中的线程数等于maximumPoolSize，则调用构造函数中的handler指定的策略来拒绝新的任务。
E.另外，当池子的线程数大于corePoolSize的时候，多余的线程会等待keepAliveTime长的时间，如果无请求可处理就自行销毁。其会优先创建 CorePoolSiz 线程， 当继续增加线程时，先放入Queue中，当 CorePoolSiz 和 Queue 都满的时候，就增加创建新线程，当线程达到MaxPoolSize的时候，就会抛出错 误 org.springframework.core.task.TaskRejectedException

3. ThreadPoolExecutor参数中的拒绝策略是什么？

ThreadPoolExecutor中默认的拒绝策略为AbortPolicy。
3.1 AbortPolicy
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
这是线程池默认的拒绝策略，在任务不能再提交的时候，抛出异常，及时反馈程序运行状态。如果是比较关键的业务，推荐使用此拒绝策略，这样子在系统不能承载更大的并发量的时候，能够及时的通过异常发现。
3.2 DiscardPolicy
ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。如果线程队列已满，则后续提交的任务都会被丢弃，且是静默丢弃。
使用此策略，可能会使我们无法发现系统的异常状态。建议是一些无关紧要的业务采用此策略。例如，本人的博客网站统计阅读量就是采用的这种拒绝策略。
3.3 DiscardOldestPolicy
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务。
此拒绝策略，是一种喜新厌旧的拒绝策略。是否要采用此种拒绝策略，还得根据实际业务是否允许丢弃老任务来认真衡量。
3.4 CallerRunsPolicy
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务，如果任务被拒绝了，则由调用线程（提交任务的线程）直接执行此任务。

4. ThreadPoolExecutor参数中的队列有几种实现？

4.1 LinkedBlockingQueue是一个无界缓存等待队列。 当前执行的线程数量达到corePoolSize的数量时，剩余的元素会在阻塞队列里等待。（所以在使用此阻塞队列时maximumPoolSizes就相当于无效了），每个线程完全独立于其他线程。生产者和消费者使用独立的锁来控制数据的同步，即在高并发的情况下可以并行操作队列中的数据。
4.2 ArrayBlockingQueue是一个有界缓存等待队列，可以指定缓存队列的大小，当正在执行的线程数等于corePoolSize时，多余的元素缓存在ArrayBlockingQueue队列中等待有空闲的线程时继续执行，当ArrayBlockingQueue已满时，加入ArrayBlockingQueue失败，会开启新的线程去执行，当线程数已经达到最大的maximumPoolSizes时，再有新的元素尝试加入ArrayBlockingQueue时会报错
4.3 SynchronousQueue没有容量，是无缓冲等待队列，是一个不存储元素的阻塞队列，会直接将任务交给消费者，必须等队列中的添加元素被消费后才能继续添加新的元素。拥有公平（FIFO）和非公平(LIFO)策略，非公平侧罗会导致一些数据永远无法被消费的情况。使用SynchronousQueue阻塞队列一般要求maximumPoolSizes为无界，避免线程拒绝执行操作。
4.4 DelayedWorkQueue是一个延迟任务的阻塞等待队列