Java 线程池 | ThreadPoolExecutor的认识与使用

分手后的思念是犯贱 2023-07-11 11:21 3阅读 0赞

#### 前言 ####

在阿里规约中，明确指定如果要使用线程，不可显式创建，而需要通过创建线程池的方式来使用线程。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70]  
并且强制推荐使用ThreadPoolExecutor的方式去创建，原因写的也很明白。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 1]

#### 线程池解决的问题是什么 ####

线程池解决的核心问题就是资源管理问题。

在并发环境下，系统不能够确定在任意时刻中，有多少任务需要执行，有多少资源需要投入。这种不确定性将带来以下若干问题：

*  频繁申请/销毁资源和调度资源，将带来额外的消耗，可能会非常巨大。
 *  对资源无限申请缺少抑制手段，易引发系统资源耗尽的风险。
 *  系统无法合理管理内部的资源分布，会降低系统的稳定性。

#### 线程池设计 ####

Java中的线程池核心实现类是ThreadPoolExecutor  
![在这里插入图片描述][20210602155602622.png]

#### 构造方法 ####

ThreadPoolExecutor总共有四个构造方法  
![在这里插入图片描述][20200305133315296.png]  
下面这个是最核心的，其他三个都基于该构造方法来构造。

public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory,
                                  RejectedExecutionHandler handler) {
        
            if (corePoolSize < 0 ||
                maximumPoolSize <= 0 ||
                maximumPoolSize < corePoolSize ||
                keepAliveTime < 0)
                throw new IllegalArgumentException();
            if (workQueue == null || threadFactory == null || handler == null)
                throw new NullPointerException();
            this.acc = System.getSecurityManager() == null ?
                    null :
                    AccessController.getContext();
            this.corePoolSize = corePoolSize;
            this.maximumPoolSize = maximumPoolSize;
            this.workQueue = workQueue;
            this.keepAliveTime = unit.toNanos(keepAliveTime);
            this.threadFactory = threadFactory;
            this.handler = handler;
        }

可以看到构造方法中总共有7个参数，分别看看是什么意思  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 2]  
handler的四种处理方法—Policy  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 3]

//无法处理的任务来到时，抛出异常
    new ThreadPoolExecutor.AbortPolicy();
    //无法处理的任务来到时，让其在调用者的线程中执行，如果Executor已经歇菜，将会丢弃这个任务
    new ThreadPoolExecutor.CallerRunsPolicy();
    //无法处理的任务来到时，丢弃队列最前面的任务，然后重新尝试执行任务
    new ThreadPoolExecutor.DiscardOldestPolicy();
    //无法处理的任务来到时，丢掉任务，不抛出异常
    new ThreadPoolExecutor.DiscardPolicy();

#### 执行流程 ####

当你使用线程池去执行任务时，线程池会以下面的流程去执行。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 4]  
需要注意的是，如果线程池中线程的数量小于`corePoolSize`，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。

#### ThreadPoolExecutor的基本使用 ####

/**
     * @author 阳光大男孩！！！
     */
    public class ThreadPoolTest {
        
        public static void main(String[] args) {
        
            ExecutorService executor = new ThreadPoolExecutor(
                    2,
                    5,
                    10,
                    TimeUnit.SECONDS,
                    new LinkedBlockingQueue<>(3),
                    Executors.defaultThreadFactory(),
                    new ThreadPoolExecutor.AbortPolicy());
    
            executor.execute(new Runnable() {
        
                @Override
                public void run() {
        
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName());
                }
            });
            executor.execute(new Runnable() {
        
                @Override
                public void run() {
        
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName());
                }
            });
            executor.execute(new Runnable() {
        
                @Override
                public void run() {
        
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName());
                }
            });
    
        }
    }

输出结果

pool-1-thread-1
    pool-1-thread-2
    pool-1-thread-1

#### 线程池的关闭 ####

ThreadPoolExecutor提供了两个方法，用于线程池的关闭。

**shutdown()**

不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务  
**shutdownNow()**

立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务

#### 线程池的生命周期 ####

ThreadPoolExecutor的运行状态有5种，分别为：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 5]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 6]

#### 线程池的分类 ####

**1、newCachedThreadPool**

创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们，并在需要时使用提供的 ThreadFactory 创建新线程。

特征：  
（1）线程池中数量没有固定，可达到最大值（Interger. MAX\_VALUE）  
（2）线程池中的线程可进行缓存重复利用和回收（回收默认时间为1分钟）  
（3）当线程池中，没有可用线程，会重新创建一个线程

创建方式： Executors.newCachedThreadPool();

**2、newFixedThreadPool**

作用：创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。

如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。

特征：  
（1）线程池中的线程处于一定的量，可以很好的控制线程的并发量  
（2）线程可以重复被使用，在显示关闭之前，都将一直存在  
（3）超出一定量的线程被提交时候需在队列中等待

创建方式：  
（1）Executors.newFixedThreadPool(int nThreads)；//nThreads为线程的数量  
（2）Executors.newFixedThreadPool(int nThreads，ThreadFactory threadFactory)；//nThreads为线程的数量，threadFactory创建线程的工厂方式

**3、newSingleThreadExecutor**

作用：创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的 newFixedThreadPool(1) 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。

特征：  
（1）线程池中最多执行1个线程，之后提交的线程活动将会排在队列中以此执行

创建方式：  
（1）Executors.newSingleThreadExecutor() ；  
（2）Executors.newSingleThreadExecutor(ThreadFactory threadFactory)；// threadFactory创建线程的工厂方式

**4、newScheduleThreadPool**  
作用： 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

特征：  
（1）线程池中具有指定数量的线程，即便是空线程也将保留  
（2）可定时或者延迟执行线程活动

创建方式：

Executors.newScheduledThreadPool(int corePoolSize)；// corePoolSize线程的个数 
    
    newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)；// corePoolSize线程的个数，threadFactory创建线程的工厂

**5、newSingleThreadScheduledExecutor**

作用： 创建一个**单线程**执行程序，它可安排在给定延迟后运行命令或者定期地执行。

特征：  
（1）线程池中最多执行1个线程，之后提交的线程活动将会排在队列中以此执行  
（2）可定时或者延迟执行线程活动

创建方式：

Executors.newSingleThreadScheduledExecutor() ； 
    Executors.newSingleThreadScheduledExecutor(ThreadFactory threadFactory) ；

##### 线程池参数方案 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 7]  
上述方案各有各的问题，所以可以考虑动态设置线程池参数。

即将线程池的参数从代码中迁移到分布式配置中心上，实现线程池参数可动态配置和即时生效

#### 参考 ####

[五种线程池的分类和作用][Link 1]  
[Java线程池实现原理及其在美团业务中的实践][Java]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2020031723162333.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200317231510309.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ==,size_16,color_FFFFFF,t_70
[20210602155602622.png]: https://img-blog.csdnimg.cn/20210602155602622.png
[20200305133315296.png]: https://img-blog.csdnimg.cn/20200305133315296.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020030513232490.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210602160903743.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200305133206408.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210602160614614.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210602160249506.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20210602161434818.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4OTg0MQ==,size_16,color_FFFFFF,t_70
[Link 1]: https://www.cnblogs.com/vince66/p/9325638.html
[Java]: https://tech.meituan.com/2020/04/02/java-pooling-pratice-in-meituan.html