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

2022-04-25 04:09:24

文章目录

前言

一、ThreadPoolExecutor 构造参数

二、newCachedThreadPool 参数分析

三、newFixedThreadPool 参数分析

四、newSingleThreadExecutor 参数分析

前言

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

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

一、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 构造函数参数 :

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

最大线程数 Integer.MAX_VALUE , 值为 2 31 − 1 2^{31} - 12

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

线程的存活时间 60 6060 秒 ;

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

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

首次创建 100000 100000100000 线程 , 性能基本相同 , 只是添加了一个线程存活时间 ;

如果再次创建 100000 100000100000 线程 , 此时线程池中的线程如果执行完毕 , 可以复用之前创建的 100000 100000100000 线程池 , 不用重新创建线程 ; 前提是期间没有间断 , 如果线程间断超过了 " 非工作线程存活时间 " , 这些线程就会被销毁 ;

三、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 , 所有的线程都是核心线程 ;

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

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

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

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

执行 100 100100 个 Runnable 任务 , 如果 10 1010 个核心线程没有满 , 则将任务提交给核心线程执行 ; 如果核心线程都满了 , 则将 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 构造函数参数 :

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

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

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

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

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

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

码农公寓

相关文章