线程池ThreadPoolExecutor的七大参数

迷南。 2022-12-20 15:53 128阅读 0赞

七个参数的构造方法如下

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

1.  核心池线程的数量 corePoolSize
2.  最大池数量 maximumPoolSize
3.  存活时间 keepAliveTime
4.  时间单位 unit （[java8新特性：在3.全新的日期时间 API有介绍][java8_3._ API]）
5.  线程阻塞队列 workQueue
6.  创建线程的工程 threadFactory
7.  超过阻塞队列时新来的线程请求拒绝策略 handler

之间的区别通过对比来理解 corePoolSize 和 maximumPoolSize

我们先看下通过Executors创建的线程池  
只观看前面两个参数

// 创建单线程的线程池
    public static ExecutorService newSingleThreadExecutor() { 
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
    // 创建固定个数的线程池
    public static ExecutorService newFixedThreadPool(int nThreads) { 
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
    // 创建可变个数的线程池
    public static ExecutorService newCachedThreadPool() { 
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

通过比较很容易理解这两个参数的意思，第一个参数corePoolSize就是池中会一直存在的个数。  
第二个参数maximumPoolSize就是这个池最多有多少个线程  
反过来自己解读Executors中提供的3个方法很容易理解3个方法方法名的含义

第三、第四个参数很容易理解就是线程池中除了 corePoolSize 个线程会一直存活以外，其它非核心的线程如果超过了规定的时间则会销毁该线程。

第五个参数则是使用那种阻塞队列，例如：newCachedThreadPool()，从其名称可知该方式创建的线程池线程数几乎没有最大值（最大值是：Integer.MAX\_VALUE，基本上到这个值前，早就OOM了，内存早不够用了），因此使用阻塞队列SynchronousQueue(特点队列长度为0的)，每来一个请求就创建一个线程去处理（这种方式很不好，很容易OOM）。

有8种阻塞队列实现了BlockingQueue接口（前面四种最常用）例如：

1.  `ArrayBlockingQueue`由数组构成的有界阻塞队列
2.  `LinkedBlockingDeque`由链表构成的有界阻塞队列（默认队列长度大小Integer.MAX\_VALUE）
3.  `SynchronousQueue`不存储元素的阻塞队列，单个元素的队列
4.  `DelayQueue`使用优先级队列实现的无界阻塞队列
5.  `DelayedWorkQueue`是ScheduledThreadPoolExecutor的静态内部类中，不对外使用，作为了解
6.  `LinkedTransferQueue`由链表构成的无界阻塞队列
7.  `LinkedBlockingDeque`由链表构成的双向阻塞队列（注意末尾单词是Deque不是Queue）
8.  `PriorityBlockingQueue`支持优先级排序的无界阻塞队列

如下图是阻塞队列接口和实现类的关系  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODEzMjA4_size_16_color_FFFFFF_t_70_pic_center]

第六个参数则是创建线程的工厂，一般来说使用`Executors.defaultThreadFactory()`就可以了

第七个参数，线程队列如果存不下新来的请求时的拒绝策略 handler

常用的拒绝策略有下面四种(`都是ThreadPoolExecutor的内部类`)

1.  AbortPolicy策略，直接拒绝并抛异常
2.  DiscardPolicy策略，直接拒绝不抛异常
3.  DiscardOldestPolicy策略，丢弃头节点，意思是丢弃等待时间最长的节点，然后加入当前请求到队列
4.  CallerRunsPolicy策略。让调用的线程来处理任务，不使用线程池的线程来处理

创建线程池填入的第七个参数的使用方式，可以直接通过new得到，例如`new ThreadPoolExecutor.AbortPolicy()`

### 面试考点： ###

#### `非核心线程会在阻塞队列满时才会创建，当核心线程被用完，新任务会加入阻塞队列中，如果一直加导致阻塞队列用完，才会创建非核心线程。` ####

以下面一段测试代码为例：  
你可以自己调试一下下面的程序

import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    public class ThreadLocalDemo { 
        public static void main(String[] args) { 
            ArrayBlockingQueue<Runnable> blockingQueue = new ArrayBlockingQueue<>(10);
            ThreadPoolExecutor threadPoolExecutor;
            threadPoolExecutor = new ThreadPoolExecutor(10, 25, 10, TimeUnit.MINUTES, blockingQueue, Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
            for (int i = 0; i < 100; i++) { 
                threadPoolExecutor.execute(
                        ()->{ 
                            System.out.println(Thread.currentThread().getName());
                            try { 
                                TimeUnit.MINUTES.sleep(10);
                            } catch (InterruptedException e) { 
                                e.printStackTrace();
                            }
                        }
                );
                if (i==20){ 
                    Object[] objects = blockingQueue.toArray();
                    System.out.println("hello");
                }
            }
            System.out.println("hello world");
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODEzMjA4_size_16_color_FFFFFF_t_70]  
当 i 的值为21时我们看下线程池中的线程数，以及阻塞队列的队列数

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODEzMjA4_size_16_color_FFFFFF_t_70 1]

[java8_3._ API]: https://blog.csdn.net/qq_41813208/article/details/107237131
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODEzMjA4_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/5d44a305afca4fa3b9635a2757f8846e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODEzMjA4_size_16_color_FFFFFF_t_70]: /images/20221120/52ab86c18cdb40cf838b4b4f63091e87.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODEzMjA4_size_16_color_FFFFFF_t_70 1]: /images/20221120/c436a48d4af44d72a05fc29ef8dea866.png