Java中的ThreadPoolExecutor线程池详解

概述

Executor 框架最核心的类是 ThreadPoolExecutor，它是线程池的实现类，主要由下列 4 个组件构成。

• corePool：核心线程池的大小。
• maximumPool：最大线程池的大小。
• BlockingQueue：用来暂时保存任务的工作队列。
• RejectedExecutionHandler：当 ThreadPoolExecutor 已经关闭或 ThreadPoolExecutor 已经饱和时（达到了最大线程池大小且工作队列已满），execute()方法将要调用的 Handler。

通过 Executor 框架的工具类 Executors，可以创建 3 种类型的 ThreadPoolExecutor。

• FixedThreadPool
• SingleThreadExecutor
• CachedThreadPool

FixedThreadPool 详解

FixedThreadPool 被称为可重用固定线程数的线程池。

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

FixedThreadPool 的 corePoolSize 和 maximumPoolSize 都被设置为创建 FixedThreadPool 时指定的参数 nThreads。

当线程池中的线程数大于 corePoolSize 时，keepAliveTime 为多余的空闲线程等待新任务的最长时间，超过这个时间后多余的线程将被终止。

这里把 keepAliveTime 设置为 0L，意味着多余的空闲线程会被立即终止。

1) 如果当前运行的线程数少于 corePoolSize，则创建新线程来执行任务。

2) 在线程池完成预热之后（当前运行的线程数等于 corePoolSize），将任务加入 LinkedBlockingQueue。

3) 线程执行完 1 中的任务后，会在循环中反复从 LinkedBlockingQueue 获取任务来 执行。

4) FixedThreadPool 使用无界队列 LinkedBlockingQueue 作为线程池的工作队列（队列的容量为 Integer.MAX_VALUE）。

使用无界队列作为工作队列会对线程池带来如下影响。

• 当线程池中的线程数达到 corePoolSize 后，新任务将在无界队列 中等待，因此线程池中的线程数不会超过 corePoolSize。
• 由于 1，使用无界队列时 maximumPoolSize 将是一个无效参数。
• 由于 1 和 2，使用无界队列时 keepAliveTime 将是一个无效参数。
• 由于使用无界队列，运行中的 FixedThreadPool（未执行方法 shutdown()或 shutdownNow()）不会拒绝任务（不会调用 RejectedExecutionHandler.rejectedExecution 方法）。

SingleThreadExecutor 详解

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 使用无界队列作为工作队列对线程池带来的影响与 FixedThreadPool 相同。

1) 如果当前运行的线程数少于 corePoolSize（即线程池中无运行的线程），则创建一个新线程来执行任务。

2) 在线程池完成预热之后（当前线程池中有一个运行的线程），将任务加入 LinkedBlockingQueue。

3) 线程执行完 1 中的任务后，会在一个无限循环中反复从 LinkedBlockingQueue 获取任务来执行。

CachedThreadPool 详解

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，即 maximumPool 是无界的。这里把 keepAliveTime 设置为 60L，意味着 CachedThreadPool 中的空闲线程等待新任务的最长时间为 60 秒，空闲线程超过 60 秒后将会被终止。

FixedThreadPool 和 SingleThreadExecutor 使用无界队列 LinkedBlockingQueue 作为线程池的工作队列。

CachedThreadPool 使用没有容量的 SynchronousQueue 作为线程池的工作队列，但 CachedThreadPool 的 maximumPool 是无界的。

这意味着，如果主线程提交任务的速度高于 maximumPool 中线程处理任务的速度时，CachedThreadPool 会不断创建新线程。极端情况下， CachedThreadPool 会因为创建过多线程而耗尽 CPU 和内存资源。

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 会创建一个新线程执行任务，execute()方法执行完成。

3) 在步骤 2）中新创建的线程将任务执行完后，会执行 SynchronousQueue.poll （keepAliveTime，TimeUnit.NANOSECONDS）。这个 poll 操作会让空闲线程最多在 SynchronousQueue 中等待 60 秒钟。如果 60 秒钟内主线程提交了一个新任务（主线程执行步骤 1）），那么这个空闲线程将执行主线程提交的新任务；否则，这个空闲线程将终止。由于空闲 60 秒的空闲线程会被终止，因此长时间保持空闲的 CachedThreadPool 不会使用任何资源。

SynchronousQueue 是一个没有容量的阻塞队列。每个插入操作必须等 待另一个线程的对应移除操作，反之亦然。CachedThreadPool 使用 SynchronousQueue， 把主线程提交的任务传递给空闲线程执行。

CachedThreadPool 的任务传递示意图

到此这篇关于Java中的ThreadPoolExecutor线程池详解的文章就介绍到这了,更多相关ThreadPoolExecutor线程池内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

最新评论