ThreadPoolExecutor 详解

·  阅读 430

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

  • 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() 方法的运行示意图如下图所示。
图10-4 FixedThreadPool 的 execute() 的运行示意图.png

  1. 如果当前运行的线程数少于 corePoolSize,则创建新线程来执行任务
  2. 在线程池完成预热之后(当前运行的线程数等于 corePoolSize),将任务加入 LinkedBlockingQueue
  3. 线程执行完1中的任务后,会在循环中反复从 LinkedBlockingQueue 获取任务来执行

FixedThreadPool 使用无界队列 LinkedBlockingQueue 作为线程池的工作队列(队列的容量为 Integer.MAX_VALUE)。使用无界队列作为工作队列会对线程池带来如下影响。

  1. 当线程池中的线程数达到 corePoolSize 后,新任务将在无界队列中等待,因此线程池中的线程数不会超过 corePoolSize
  2. 由于1,使用无界队列时 maximumPoolSize 将是一个无效参数
  3. 由于1和2,使用无界队列时 keepAliveTime 将是一个无效参数
  4. 由于使用无界队列,运行中的 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 的运行示意图如图所示
图10-5 SingleThreadExecutor 的 execute() 的运行示意图.png

  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() 方法的执行示意图如下所示

图10-6 CachedThreadPool 的 execute() 的运行示意图.png

  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 中任务传递的示意图如下图所示

图10-7 CachedThreadPool 的任务传递示意图.png

分类:
Android
标签:
分类:
Android
标签:
收藏成功!
已添加到「」, 点击更改