ThreadPoolExecutor运转机制详解

一、原理:

最近,在工作中接触到ThreadPoolExecutor,在这里记录一下相关的知识点,以便今后使用。

先看一下新建一个ThreadPoolExecutor的构建参数:

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

看这个参数很容易让人以为是线程池里保持corePoolSize个线程,如果不够用,就加线程入池直至maximumPoolSize大小,如果还不够就往workQueue里加,如果workQueue也不够就用RejectedExecutionHandler来做拒绝处理。

但实际情况不是这样,具体流程如下:

1)当池子大小小于corePoolSize就新建线程,并处理请求

2)当池子大小等于corePoolSize,把请求放入workQueue中,池子里的空闲线程就去从workQueue中取任务并处理

3)当workQueue放不下新入的任务时,新建线程入池,并处理请求,如果池子大小撑到了maximumPoolSize就用RejectedExecutionHandler来做拒绝处理

4)另外,当池子的线程数大于corePoolSize的时候,多余的线程会等待keepAliveTime长的时间,如果无请求可处理就自行销毁

内部结构如下所示:

从中可以发现ThreadPoolExecutor就是依靠BlockingQueue的阻塞机制来维持线程池,当池子里的线程无事可干的时候就通过workQueue.take()阻塞住。

其实可以通过Executes来学学几种特殊的ThreadPoolExecutor是如何构建的。

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

newFixedThreadPool就是一个固定大小的ThreadPool

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

newCachedThreadPool比较适合没有固定大小并且比较快速就能完成的小任务,没必要维持一个Pool,这比直接new Thread来处理的好处是能在60秒内重用已创建的线程。

其他类型的ThreadPool看看构建参数再结合上面所说的特性就大致知道它的特性

二、排队

排队有三种通用策略:

  1. 直接提交。工作队列的默认选项是 SynchronousQueue,它将任务直接提交给线程而不保持它们。在此,如果不存在可用于立即运行任务的线程,则试图把任务加入队列将失败,因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时,此策略允许无界线程具有增长的可能性。
  2. 无界队列。使用无界队列(例如,不具有预定义容量的 LinkedBlockingQueue)将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样,创建的线程就不会超过 corePoolSize。(因此,maximumPoolSize 的值也就无效了。)当每个任务完全独立于其他任务,即任务执行互不影响时,适合于使用无界队列;例如,在 Web 页服务器中。这种排队可用于处理瞬态突发请求,当命令以超过队列所能处理的平均数连续到达时,此策略允许无界线程具有增长的可能性。
  3. 有界队列。当使用有限的 maximumPoolSizes 时,有界队列(如 ArrayBlockingQueue)有助于防止资源耗尽,但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷:使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销,但是可能导致人工降低吞吐量。如果任务频繁阻塞(例如,如果它们是 I/O 边界),则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小,CPU 使用率较高,但是可能遇到不可接受的调度开销,这样也会降低吞吐量。
三、被拒绝的任务

当 Executor 已经关闭,并且 Executor 将有限边界用于最大线程和工作队列容量,且已经饱和时,在方法 execute(java.lang.Runnable) 中提交的新任务将被拒绝。在以上两种情况下,execute 方法都将调用其RejectedExecutionHandlerRejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四种预定义的处理程序策略:

  1. 在默认的 ThreadPoolExecutor.AbortPolicy 中,处理程序遭到拒绝将抛出运行时RejectedExecutionException
  2. ThreadPoolExecutor.CallerRunsPolicy 中,线程调用运行该任务的execute 本身。此策略提供简单的反馈控制机制,能够减缓新任务的提交速度。
  3. ThreadPoolExecutor.DiscardPolicy 中,不能执行的任务将被删除。
  4. ThreadPoolExecutor.DiscardOldestPolicy 中,如果执行程序尚未关闭,则位于工作队列头部的任务将被删除,然后重试执行程序(如果再次失败,则重复此过程)。

定义和使用其他种类的 RejectedExecutionHandler 类也是可能的,但这样做需要非常小心,尤其是当策略仅用于特定容量或排队策略时。 

公用的类ThreadPoolTask

public class ThreadPoolTask implements Runnable { 
  // 保存任务所需要的数据 
  private Object threadPoolTaskData; 
  private static int consumerTaskSleepTime = 2000; 

  ThreadPoolTask(Object tasks) { 
    this.threadPoolTaskData = tasks; 
  } 

  public void run() { 
    // 处理一个任务,这里的处理方式太简单了,仅仅是一个打印语句 
    System.out.println("start .." + threadPoolTaskData); 
    try { 
      //便于观察,等待一段时间 
      Thread.sleep(consumerTaskSleepTime); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
    System.out.println("finish " + threadPoolTaskData); 
    threadPoolTaskData = null; 
  } 

} 

ThreadPoolExecutor.AbortPolicy

import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 

public class ThreadPool { 
  
  //让可执行程序休息一下
  private static int executePrograms = 0; 
  private static int produceTaskMaxNumber = 10; 

  public static void main(String[] args) { 
    // 构造一个线程池 
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, 
        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3), 
        new ThreadPoolExecutor.CallerRunsPolicy()); 

    for (int i = 1; i <= produceTaskMaxNumber; i++) { 
      try { 
        String task = "task@ " + i; 
        System.out.println("put " + task); 
        threadPool.execute(new ThreadPoolTask(task)); 

        // 便于观察,等待一段时间 
        Thread.sleep(executePrograms); 
      } catch (Exception e) { 
        e.printStackTrace(); 
      } 
    } 
  } 
} 

运行结果

put task@ 1
put task@ 2
start ..task@ 1
put task@ 3
put task@ 4
start ..task@ 2
put task@ 5
put task@ 6
put task@ 7
start ..task@ 6
put task@ 8
start ..task@ 7
java.util.concurrent.RejectedExecutionException
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.reject(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.execute(Unknown Source)
	at ThreadPool.main(ThreadPool.java:22)
put task@ 9
java.util.concurrent.RejectedExecutionException
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.reject(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.execute(Unknown Source)
	at ThreadPool.main(ThreadPool.java:22)
put task@ 10
java.util.concurrent.RejectedExecutionException
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.reject(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor.execute(Unknown Source)
	at ThreadPool.main(ThreadPool.java:22)
finish task@ 2
finish task@ 6
finish task@ 7
start ..task@ 4
start ..task@ 3
finish task@ 1
start ..task@ 5
finish task@ 4
finish task@ 3
finish task@ 5

ThreadPoolExecutor.CallerRunsPolicy

import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 

public class ThreadPool { 
  
  //让可执行程序休息一下
  private static int executePrograms = 0; 
  private static int produceTaskMaxNumber = 10; 

  public static void main(String[] args) { 
    // 构造一个线程池 
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, 
        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3), 
        new ThreadPoolExecutor.CallerRunsPolicy()); 

    for (int i = 1; i <= produceTaskMaxNumber; i++) { 
      try { 
        String task = "task@ " + i; 
        System.out.println("put " + task); 
        threadPool.execute(new ThreadPoolTask(task)); 

        // 便于观察,等待一段时间 
        Thread.sleep(executePrograms); 
      } catch (Exception e) { 
        e.printStackTrace(); 
      } 
    } 
  } 
} 

运行结果

put task@ 1
put task@ 2
start ..task@ 1
put task@ 3
start ..task@ 2
put task@ 4
put task@ 5
put task@ 6
put task@ 7
start ..task@ 6
put task@ 8
start ..task@ 8
start ..task@ 7
finish task@ 2
finish task@ 1
start ..task@ 3
start ..task@ 4
finish task@ 6
start ..task@ 5
finish task@ 7
finish task@ 8
put task@ 9
put task@ 10
start ..task@ 9
finish task@ 4
finish task@ 3
start ..task@ 10
finish task@ 9
finish task@ 5
finish task@ 10

ThreadPoolExecutor.DiscardPolicy
import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 

public class ThreadPool { 
  
  //让可执行程序休息一下
  private static int executePrograms = 0; 
  private static int produceTaskMaxNumber = 10; 

  public static void main(String[] args) { 
    // 构造一个线程池 
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, 
        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3), 
        new ThreadPoolExecutor.CallerRunsPolicy()); 

    for (int i = 1; i <= produceTaskMaxNumber; i++) { 
      try { 
        String task = "task@ " + i; 
        System.out.println("put " + task); 
        threadPool.execute(new ThreadPoolTask(task)); 

        // 便于观察,等待一段时间 
        Thread.sleep(executePrograms); 
      } catch (Exception e) { 
        e.printStackTrace(); 
      } 
    } 
  } 
} 

运行结果

put task@ 1
put task@ 2
start ..task@ 1
put task@ 3
start ..task@ 2
put task@ 4
put task@ 5
put task@ 6
put task@ 7
start ..task@ 6
put task@ 8
put task@ 9
start ..task@ 7
put task@ 10
finish task@ 2
finish task@ 1
start ..task@ 3
start ..task@ 4
finish task@ 7
finish task@ 6
start ..task@ 5
finish task@ 3
finish task@ 4
finish task@ 5

ThreadPoolExecutor.DiscardOldestPolicy
import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 

public class ThreadPool { 
  
  //让可执行程序休息一下
  private static int executePrograms = 0; 
  private static int produceTaskMaxNumber = 10; 

  public static void main(String[] args) { 
    // 构造一个线程池 
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, 
        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3), 
        new ThreadPoolExecutor.CallerRunsPolicy()); 

    for (int i = 1; i <= produceTaskMaxNumber; i++) { 
      try { 
        String task = "task@ " + i; 
        System.out.println("put " + task); 
        threadPool.execute(new ThreadPoolTask(task)); 

        // 便于观察,等待一段时间 
        Thread.sleep(executePrograms); 
      } catch (Exception e) { 
        e.printStackTrace(); 
      } 
    } 
  } 
} 

运行结果

put task@ 1
put task@ 2
start ..task@ 1
put task@ 3
start ..task@ 2
put task@ 4
put task@ 5
put task@ 6
put task@ 7
start ..task@ 6
put task@ 8
start ..task@ 7
put task@ 9
put task@ 10
finish task@ 6
finish task@ 7
start ..task@ 8
finish task@ 1
start ..task@ 9
finish task@ 2
start ..task@ 10
finish task@ 8
finish task@ 9
finish task@ 10


keepAliveTime

jdk中的解释是:当线程数大于核心时,此为终止前多余的空闲线程等待新任务的最长时间。

有点拗口,其实这个不难理解,在使用了“池”的应用中,大多都有类似的参数需要配置。比如数据库连接池,DBCP中的maxIdle,minIdle参数。

什么意思?接着上面的解释,后来向老板派来的工人始终是“借来的”,俗话说“ 有借就有还”,但这里的问题就是 什么时候还了,如果借来的工人刚完成一个任务就还回去,后来发现任务还有,那岂不是又要去借?这一来一往,老板肯定头也大死了。

合理的策略:既然借了,那就多借一会儿。直到“ 某一段”时间后,发现再也用不到这些工人时,便可以还回去了。这里的某一段时间便是keepAliveTime的含义,TimeUnit为keepAliveTime值的度量。


备注:

既然最终任务都是由execute(Runnable)方法执行,就直接来看该方法实现的所在类。首当其冲肯定是类ThreadPoolExecutor了,相信他是java concurrent包中用的最多的一个

线程池执行器,包括spring中ThreadPoolTaskExecutor也是利用它来执行任务的。从类的“家谱”来看,ThreadPoolExecutor直接继承自AbstractExecutorService,因此必须实现的方法只有public void execute(Runnable command),查看之发现和想象不一样(原以为他会直接以此runnable创建一个thread然后直接start, ^_^),他内部还会其他的执行逻辑,那是因为ThreadPoolExecutor内部会维护一个线程池,所以有很多额外的操作。



  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值