ScheduledThreadPoolExecutor 及 ThreadPoolExecutor的基本使用及说明

以你之姓@ 2023-10-14 09:07 21阅读 0赞

> 关于作者：CSDN内容合伙人、技术专家， 从零开始做日活千万级APP。  
> 专注于分享各领域原创系列文章 ，擅长java后端、移动开发、人工智能等，希望大家多多支持。

#### 目录 ####

*  一、导读
 *  二、概览
 *   *  2.1 为什么不推荐使用Executors去创建线程池
 *  三、使用
 *   *  3.1 ThreadPoolExecutor
     *  3.2 ScheduledThreadPoolExecutor
     *   *  3.2.1 通过构造方法创建
         *  3.2.2 通过Executors工厂方法创建
         *  3.2.3 ScheduledThreadPoolExecutor与ThreadPoolExecutor异同
 *  四、 推荐阅读

![ddd][]

## 一、导读 ##

我们继续总结学习**Java基础知识**，温故知新。

本文讲述 ScheduledThreadPoolExecutor 及 ThreadPoolExecutor。

## 二、概览 ##

我们并不推荐使用Executors去创建线程池，为了更好地控制和管理线程池，通过ThreadPoolExecutor或者ScheduledThreadPoolExecutor的方式去创建线程池。这两种方式可以根据具体的需求设置线程池的参数，例如核心线程数、最大线程数、队列类型等，以及自定义拒绝策略来处理任务无法执行的情况。

### 2.1 为什么不推荐使用Executors去创建线程池 ###

newFixedThreadPool（固定线程数）  
newSingleThreadExecutor（单线程）  
主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。线程数固定，任务多了之后容易堆积。

newCachedThreadPool（可缓存的线程池）  
newScheduledThreadPool（定时执行的线程池）  
主要问题是线程数最大数是Integer.MAX\_VALUE，可能会创建数量非常多的线程，甚至OOM。不限定线程多数量，任务一多，容易创建无限多线程。

## 三、使用 ##

![在这里插入图片描述][f926a1239c45465cbf11667ab4046e27.png]

### 3.1 ThreadPoolExecutor ###

public class ThreadPoolDemo {
        
        private static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
          2,   // 核心线程数
          10,  // 最大线程数
          10L, // 线程 存活时间
          TimeUnit.SECONDS,  // 线程存活时间单位
          new LinkedBlockingQueue(100));// 缓冲队列
        
        public static void main(String[] args) {
        
            threadPoolExecutor.execute(new Runnable() {
        
                @Override
                public void run() {
        
                }
            });
        }
    }

构造方法

public ThreadPoolExecutor(
        // 线程池核心线程数
        int corePoolSize, 
        // 线程池最大数
        int maximumPoolSize, 
        // 空闲线程存活时间
        long keepAliveTime,  
        // 时间单位
        TimeUnit unit,
        // 线程池所使用的缓冲队列
        BlockingQueue<Runnable> workQueue,
        // 线程池创建线程使用的工厂
        ThreadFactory threadFactory,
        // 线程池对拒绝任务的处理策略
        RejectedExecutionHandler handler)

处理任务的优先级为核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。

### 3.2 ScheduledThreadPoolExecutor ###

ScheduledThreadPoolExecutor 是 Java 8 引入的一个新特性，继承自ThreadPoolExecutor。  
它们都提供了一些基本的线程池操作，如 execute() 方法用于执行任务，schedule() 方法用于**延迟**或**定时**执行任务。  
不同之处在于 ScheduledThreadPoolExecutor 可以根据指定的周期和时间间隔来调度任务执行，从而实现周期性执行任务的效果。

ScheduledThreadPoolExecutor用于替代Timer，比Timer更强大，更灵活，Timer对应的是单个后台线程，而ScheduledThreadPoolExecutor可以在构造函数中指定多个对应的后台线程数。

ScheduledThreadPoolExecutor 内部构造了两个内部类 ScheduledFutureTask 和 DelayedWorkQueue，基于这两个类实现。

有两种创建方式：

#### 3.2.1 通过构造方法创建 ####

new ScheduledThreadPoolExecutor(int corePoolSize, // 核心线程数
                                    ThreadFactory threadFactory, //主要作用是用来捕获异常和设置线程名称
                                    RejectedExecutionHandler handler) //拒绝策略
    
    
    ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
    executor.execute(...);
    executor.shutdown(...);
    executor.schedule(...);
    executor.scheduleAtFixedRate(...);
    executor.scheduleWithFixedDelay(...);
    executor.submit(...);

#### 3.2.2 通过Executors工厂方法创建 ####

方式一：
    newSingleThreadScheduledExecutor（） 只有一个工作线程的线程池。如果内部工作线程由于执行周期任务异常而被终止，则会新建一个线程替代它的位置。
    
    
    方式二：
    Executors.newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)
    
    
    ScheduledExecutorService service = Executors.newScheduledThreadPool(1);
    
    service.execute(...);
    service.shutdown(...);
    service.schedule(...);
    service.scheduleAtFixedRate(...);
    service.scheduleWithFixedDelay(...);
    service.submit(...);

我们常用的方法有以下一些

/**
      创建并执行在给定延迟后启用的一次性操作
     * @param command 执行的任务
     * @param delay 延迟的时间
     * @param unit 延迟的时间单位
     */
    schedule(Runnable command, long delay, TimeUnit unit)
    
    
    周期任务，在第一次执行完之后延迟delay后开始下一次执行，重点是任务执行完后才开始下一次。
    如果任务执行过程抛出异常，不会再执行该任务！
    /**
      定时执行 周期任务，
      在initialDelay后开始调度该任务，任务执行完成后，延迟 delay 时间再次执行
      
     * @param command 执行的任务
     * @param initialDelay 初始延迟的时间
     * @param delay 延迟的时间
     * @param unit 延迟的时间单位
     */
    scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
    
    
    周期任务，第一次执行延期时间为initialDelay，之后每隔period执行一次
    如果任务执行过程抛出异常，不会再执行该任务！
    /**
      按照固定的评率定时执行周期任务，不受任务运行时间影响。
      在initialDelay后开始调度该任务，然后 delay 时间后再次执行
      
      如果任务执行的时间比period长的话，会导致该任务延迟执行，不会同时执行
     * @param command 执行的任务
     * @param initialDelay 初始延迟的时间
     * @param period 延迟的时间
     * @param unit 延迟的时间单位
     */
    scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)

ScheduledThreadPoolExecutor 有两个关闭策略：

1.  关闭策略 1：在任务队列为空时，调用 shutdown() 方法关闭线程池。
2.  关闭策略 2：当线程池中的所有任务都执行完毕时，调用 shutdown() 方法关闭线程池。

这两个关闭策略的区别在于，当线程池中的任务队列为空时，调用 shutdown() 方法关闭线程池可以立即关闭线程池，避免了等待任务执行完毕的时间开销。而当线程池中的任务都执行完毕时，调用 shutdown() 方法关闭线程池则无法立即关闭线程池，需要等待所有任务执行完毕后才能关闭线程池。

其他的比较简单，就不列出来。

使用 ScheduledThreadPoolExecutor 时一定要注意**异常处理**， 如果使用不当，会导致定时任务不再执行。

#### 3.2.3 ScheduledThreadPoolExecutor与ThreadPoolExecutor异同 ####

1.  ThreadPoolExecutor 是一个普通的线程池实现，用于执行提交的任务。它不提供定时调度任务的功能。而ScheduledThreadPoolExecutor 是ThreadPoolExecutor的子类，它扩展了线程池的功能，可以执行延迟任务和定时任务。
2.  ThreadPoolExecutor 是基于工作队列的线程池，它使用工作队列来保存需要执行的任务，并通过线程池中的工作线程来执行这些任务。ScheduledThreadPoolExecutor 在ThreadPoolExecutor的基础上添加了一个调度器，用于管理延迟任务和定时任务的执行。
3.  ThreadPoolExecutor 默认情况下是**懒汉式**创建线程，即在需要执行任务时才创建线程；而ScheduledThreadPoolExecutor 在初始化时就会**一次性创建指定数量的线程**，这些线程会一直存在，用于执行被调度的任务。

## 四、 推荐阅读 ##

[Java 专栏][Java]

[SQL 专栏][SQL]

[数据结构与算法][Link 1]

[Android学习专栏][Android]

![在这里插入图片描述][f5ba2a630958460ab6a581523327cf4d.png]

[ddd]: https://img-blog.csdnimg.cn/004fcf994a0b443ab491ca3bd590e764.png
[f926a1239c45465cbf11667ab4046e27.png]: https://img-blog.csdnimg.cn/f926a1239c45465cbf11667ab4046e27.png
[Java]: https://blog.csdn.net/fumeidonga/category_12311533.html
[SQL]: http://t.csdn.cn/4i3TW
[Link 1]: http://t.csdn.cn/9gGNy
[Android]: http://t.csdn.cn/A0aTR
[f5ba2a630958460ab6a581523327cf4d.png]: https://img-blog.csdnimg.cn/f5ba2a630958460ab6a581523327cf4d.png