【Java 并发编程】线程池机制 ( ThreadPoolExecutor 线程池构造参数分析 | 核心线程数 | 最大线程数 | 非核心线程存活时间 | 任务阻塞队列 )

前言

在上一篇博客 【Java 并发编程】线程池机制 ( 线程池示例 | newCachedThreadPool | newFixedThreadPool | newSingleThreadExecutor ) 使用了 3 3 3 种类型的线程池 , 3 3 3 种线程池都使用了 ThreadPoolExecutor , 该类时线程池的核心 ;

本篇博客中分析这 3 3 3 种线程池 ;

一、ThreadPoolExecutor 构造参数

ThreadPoolExecutor 是线程池中最核心的类 , 其构造函数如下 :

    public ThreadPoolExecutor(int corePoolSize,					// 核心线程数 , 这些线程基本不会被销毁
                              int maximumPoolSize, 				// 最大线程数 , 线程池能创建的最大线程数量
                              long keepAliveTime, 				// 空闲情况下 , 非核心线程存活时间
                              TimeUnit unit, 					// 空闲时间单位
                              BlockingQueue workQueue,// 任务的阻塞队列
                              ThreadFactory threadFactory, 		// 创建线程的工厂类
                              RejectedExecutionHandler handler) // 拒绝策略

int corePoolSize 核心线程数 , 这些线程基本不会被销毁 ;

int maximumPoolSize 最大线程数 , 线程池能创建的最大线程数量 , 包括 核心线程 + 非核心线程 ;

long keepAliveTime 空闲情况下 , 非核心线程存活时间 ;

TimeUnit unit 空闲时间单位 ;

BlockingQueue workQueue 任务的阻塞队列 , 任务设置到线程池后 , 在该队列中排队等待执行 ;

ThreadFactory threadFactory 创建线程的工厂类 ;

RejectedExecutionHandler handler 拒绝策略 , 如果线程池已满 , 如果再放入新的任务后的拒绝策略

二、newCachedThreadPool 参数分析

ExecutorService executorService1 = Executors.newCachedThreadPool(); 创建线程池代码如下 :

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

分析上述代码中 ThreadPoolExecutor 构造函数参数 :

核心线程数 0 0 0 , 没有核心线程 ;

最大线程数 Integer.MAX_VALUE , 值为 2 31 − 1 2^{31} - 1 231−1 , 这些线程都是非核心线程 , 是无限大的 ; 注意这里有 OOM 风险 ;

线程的存活时间 60 60 60 秒 ;

使用的等待队列是 SynchronousQueue 队列 ;

SynchronousQueue 队列不存储元素 , 后一个 Runnable 任务入队 , 必须等到前一个任务执行完毕才可以 , 否则会一直阻塞等待 ;

使用该线程池 , 如果执行 100000 100000 100000 个 Runnable 任务 , 则会创建 100000 100000 100000 个线程 , 与 【Java 并发编程】线程池机制 ( 测试线程开销 | 启动线程分析 | 用户态 | 内核态 | 用户线程 | 内核线程 | 轻量级进程 ) 一、测试线程开销 1、正常测试 章节测试 ;

• 首次创建 100000 100000 100000 线程 , 性能基本相同 , 只是添加了一个线程存活时间 ;
• 如果再次创建 100000 100000 100000 线程 , 此时线程池中的线程如果执行完毕 , 可以复用之前创建的 100000 100000 100000 线程池 , 不用重新创建线程 ; 前提是期间没有间断 , 如果线程间断超过了 " 非工作线程存活时间 " , 这些线程就会被销毁 ;

三、newFixedThreadPool 参数分析

ExecutorService executorService2 = Executors.newFixedThreadPool(10); 创建线程池代码如下 :

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

分析上述代码中 ThreadPoolExecutor 构造函数参数 :

核心线程数是 nThreads , 这是传入的参数 ;

最大线程数 nThreads , 核心线程数是 nThreads , 所有的线程都是核心线程 ;

非核心线程的存活时间 0 0 0 毫秒 ; 由于所有线程都是核心线程 , 设置非核心线程存货事件意义不大 ;

使用的等待队列是 LinkedBlockingQueue 队列 ;

LinkedBlockingQueue 队列是基于链表的阻塞队列 , 该队列吞吐量高于 ArrayBlockingQueue 队列 , 低于 SynchronousQueue 队列 ;

假设核心线程数为 10 10 10 , 有 100 100 100 个任务需要执行 ;

执行 100 100 100 个 Runnable 任务 , 如果 10 10 10 个核心线程没有满 , 则将任务提交给核心线程执行 ; 如果核心线程都满了 , 则将 Runnable 任务放到 LinkedBlockingQueue 等待队列 , 假如该等待队列中任务也满了 , 则需要执行 RejectedExecutionHandler handler 拒绝策略 ;

该拒绝策略默认是 defaultHandler ;

    private static final RejectedExecutionHandler defaultHandler =
        new AbortPolicy();

四、newSingleThreadExecutor 参数分析

ExecutorService executorService3 = Executors.newSingleThreadExecutor(); 创建线程池代码如下 :

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

分析上述代码中 ThreadPoolExecutor 构造函数参数 :

核心线程数是 1 1 1 , 只有 1 1 1 个核心线程 ;

最大线程数 1 1 1 , 核心线程数是 1 1 1 , 所有的线程都是核心线程 ;

非核心线程的存活时间 0 0 0 毫秒 ; 由于所有线程都是核心线程 , 设置非核心线程存货事件意义不大 ;

使用的等待队列是 LinkedBlockingQueue 队列 ;

LinkedBlockingQueue 队列是基于链表的阻塞队列 , 该队列吞吐量高于 ArrayBlockingQueue 队列 , 低于 SynchronousQueue 队列 ;

整个线程池只有 1 1 1 个核心线程在工作 ; 100 100 100 个任务在 LinkedBlockingQueue 任务队列中排队等待执行 ;