ThreadPoolExecutor 详解

Executor 框架最核心的类是 ThreadPoolExecutor，它是线程池的实现类，参数如下：

• corePool：核心线程池的大小
• maximumPool：最大线程池的大小
• BlockingQueue：用来暂时保存任务的工作队列
• RejectedExecutionHandler：当 ThreadPoolExecutor 已经关闭或已经饱和时（达到了最大线程池大小且工作队列已满），execute() 方法将调用的 Handler
  通过 Executor 框架的工具类 Executors，可以创建3种类型的 ThreadPoolExecutor
• FixedThreadPool
• SingleThreadExecutor
• CachedThreadPool

FixedThreadPool 详解

可重用固定线程数的线程池

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

FixedThreadPool 的 corePoolSize 和 maximumPoolSize 都被设置为创建 FixedThreadPool 时指定的参数 nThreads。
FixedThreadPool 的 execut() 方法的运行示意图如下图所示。

1. 如果当前运行的线程数少于 corePoolSize，则创建新线程来执行任务
2. 在线程池完成预热之后（当前运行的线程数等于 corePoolSize），将任务加入 LinkedBlockingQueue
3. 线程执行完1中的任务后，会在循环中反复从 LinkedBlockingQueue 获取任务来执行
   FixedThreadPool 使用无界队列 LinkedBlockingQueue 作为线程池的工作队列（队列的容量为 Integer.MAX_VALUE）。使用无界队列作为工作队列会对线程池带来如下影响。
4. 当线程池中的线程数达到 corePoolSize 后，新任务将在无界队列中等待，因此线程池中的线程数不会超过 corePoolSize
5. 由于1，使用无界队列时 maximumPoolSize 将是一个无效参数
6. 由于1和2，使用无界队列时 keepAliveTime 将是一个无效参数
7. 由于使用无界队列，运行中的 FixedThreadPool 不会拒绝任务（不会调用 RejectedExecutionHandler.rejectedExecution 方法）

SingleThreadExecutor 详解

使用单个 worker 线程的 Executor

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

SingleThreadExecutor 的 corePoolSize 和 maximumPoolSize 被设置为 1。其他参数与 FixedThreadPool 相同。SingleThreadExecutor 使用无界队列 LinkedBlockingQueue 作为线程池的工作队列（队列的容量为 Integer.MAX_VALUE）。
SingleThreadExecutor 的运行示意图如图所示

1. 如果当前运行的线程数少于 1，则创建一个新线程来执行任务
2. 在线程池完成预热之后（当前线程池中有一个运行的线程），将任务加入 LinkedBlockingQueue
3. 线程执行完 1 中的任务后，会在一个无限循环中反复从 LinkedBlockingQueue 获取任务来执行

CachedThreadPool 详解

是一个会根据需要创建新线程的线程池

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

CachedThreadPool 的 corePoolSize 被设置为 0，即 corePool 为控；maximumPoolSize 被设置为 Integer.MAX_VALUE，即 maximumPoolSize 是无界的。这里把 keepAliveTime 设置为60L，意味着 CachedThreadPool 中的空闲线程等待新任务的最长时间为60秒，空闲线程超过60秒后将会终止。
CachedThreadPool 使用没有容量的 SynchronousQueue 作为线程池的工作队列，但 maximumPool 是无界的。这意味着如果主线程提交任务的速度高于 maximumPool 中线程处理任务的速度时，CachedThreadPool 会不断创建新线程。极端情况下，CachedThreadPool 会因为创建过多线程而耗尽CPU和内存资源。
CachedThreadPool 的 execut() 方法的执行示意图如下所示

1. 首先执行 SynchronousQueue.offer(Runnable task)。如果当前 maximumPool 中有空闲线程正在执行 SynchronousQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)，那么主线程执行 offer 操作与空闲线程执行的 poll 操作配对成功，主线程把任务交给空闲线程执行，execute() 方法执行完成；否则执行下面的步骤2
2. 当初始 maximumPool 为空，或者 maximumPool 中当前没有空闲线程时，将没有线程执行 SynchronousQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)。这种情况下，步骤1将失败。此时 CachedThreadPool 会创建一个新线程执行任务，execut() 方法执行完成
3. 在步骤2中新创建的线程将任务执行完成后，会执行 SynchronousQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)。这个 poll 操作会让空闲线程最多在 SynchronousQueue 中等待60秒钟。如果60秒钟内主线程提交了一个新任务（主线程执行步骤1），那么这个空闲线程将执行主线程提交的新任务；否则，这个空闲线程将终止。由于空闲60秒的空闲线程会被终止，因此长时间保持空闲的 CachedThreadPool 不会使用任何的资源。
   前面提到过，SynchronousQueue 是一个没有容量的阻塞队列。每个插入操作/添加（offer/put）必须等到另一个线程的对应移除（poll/take）操作，否则不能继续添加元素，反之亦然。SynchronousQueue 可以看成是一个传球手，负责把生产者处理的数据直接传递给消费之线程，队列本身不存储元素，非常适合传递性场景。其吞吐量高于 LinkedBlockingQueue。CachedThreadPool 使用 SynchronousQueue 把主线程的任务传递给空闲线程执行。CachedThreadPool 中任务传递的示意图如下图所示