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

文章目录

• 前言
• 一、ThreadPoolExecutor 构造参数
• 二、newCachedThreadPool 参数分析
• 三、newFixedThreadPool 参数分析
• 四、newSingleThreadExecutor 参数分析

前言

在上一篇博客 【Java 并发编程】线程池机制 ( 线程池示例 | newCachedThreadPool | newFixedThreadPool | newSingleThreadExecutor ) 使用了

种类型的线程池 ,

种线程池都使用了 ThreadPoolExecutor , 该类时线程池的核心 ;

本篇博客中分析这

种线程池 ;

一、ThreadPoolExecutor 构造参数

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

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

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

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

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

TimeUnit unit 空闲时间单位 ;

BlockingQueue<Runnable> 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<Runnable>());
    }

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

核心线程数

, 没有核心线程 ;

最大线程数 Integer.MAX_VALUE , 值为

, 这些线程都是非核心线程 , 是无限大的 ; 注意这里有 OOM 风险 ;

线程的存活时间

秒 ;

使用的等待队列是 SynchronousQueue<Runnable> 队列 ;

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

使用该线程池 , 如果执行

个 Runnable 任务 , 则会创建

个线程 , 与 【Java 并发编程】线程池机制 ( 测试线程开销 | 启动线程分析 | 用户态 | 内核态 | 用户线程 | 内核线程 | 轻量级进程 ) 一、测试线程开销 1、正常测试 章节测试 ;

• 首次创建

线程 , 性能基本相同 , 只是添加了一个线程存活时间 ;

• 如果再次创建

线程 , 此时线程池中的线程如果执行完毕 , 可以复用之前创建的

线程池 , 不用重新创建线程 ; 前提是期间没有间断 , 如果线程间断超过了 " 非工作线程存活时间 " , 这些线程就会被销毁 ;

三、newFixedThreadPool 参数分析

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

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

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

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

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

非核心线程的存活时间

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

使用的等待队列是 LinkedBlockingQueue<Runnable> 队列 ;

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

假设核心线程数为

, 有

个任务需要执行 ;

执行

个 Runnable 任务 , 如果

个核心线程没有满 , 则将任务提交给核心线程执行 ; 如果核心线程都满了 , 则将 Runnable 任务放到 LinkedBlockingQueue<Runnable> 等待队列 , 假如该等待队列中任务也满了 , 则需要执行 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<Runnable>()));
    }

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

核心线程数是

, 只有

个核心线程 ;

最大线程数

, 核心线程数是

, 所有的线程都是核心线程 ;

非核心线程的存活时间

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

使用的等待队列是 LinkedBlockingQueue<Runnable> 队列 ;

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

整个线程池只有

个核心线程在工作 ;

个任务在 LinkedBlockingQueue<Runnable> 任务队列中排队等待执行 ;