【JUC并发编程】5 定时任务线程池ScheduledThreadPoolExecutor的使用

「爱情、让人受尽委屈。」 2023-10-05 07:56 134阅读 0赞

#### 1. ScheduledThreadPoolExecutor介绍 ####

*  ScheduledThreadPoolExecutor继承自ThreadPoolExecutor。它主要用来在给定的延迟之后执行任务，或者定期执行任务。通常使用工厂类Executors来创建。
 *  ScheduledThreadPoolExecutor的功能与Timer类似，但比Timer更强大，更灵活，Timer对应的是单个后台线程，而ScheduledThreadPoolExecutor可以在构造函数中指定多个对应的后台线程数。

#### 2.ScheduledThreadPoolExecutor的两种类型 ####

1.  ScheduledThreadPoolExecutor：执行并行任务也就是多条线程同时执行。
2.  SingleThreadScheduledExecutor：执行单条线程。

##### 2.1. ScheduledThreadPoolExecutor #####

使用Executors创建ScheduledThreadPoolExecutor的方法构造如下：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        
            return new ScheduledThreadPoolExecutor(corePoolSize);
        }
        
    public static ScheduledExecutorService newScheduledThreadPool(
                int corePoolSize, ThreadFactory threadFactory) {
        
            return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
        }

##### 2.2. SingleThreadScheduledExecutor #####

使用Executors创建SingleThreadScheduledExecutor的方法构造如下：

public static ExecutorService newSingleThreadExecutor() {
        
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>()));
        }
        
    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>(),
                                        threadFactory));
        }

##### 2.3. 创建实例 #####

ScheduledExecutorService scheduledThreadPoolExecutor=Executors.newScheduledThreadPool(5);
    
    ScheduledExecutorService singleThreadScheduledExecutor=Executors.newSingleThreadScheduledExecutor();

##### 2.4 使用场景 #####

*  ScheduledThreadPoolExecutor：适用于多个后台线程执行周期性任务，同时为了满足资源管理的需求而需要限制后台线程数量的应用场景。
 *  SingleThreadScheduledExecutor：适用于需要单个后台线程执行周期任务，同时需要保证任务顺序执行的应用场景。

#### 3. ScheduledThreadPoolExecutor执行机制分析 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NhaW50bW0_size_16_color_FFFFFF_t_70]  
**注意：DelayQueue是一个无界队列，所以ThreadPoolExecutor的maximumPoolSize在ScheduledThreadPoolExecutor中无意义。**

**ScheduledThreadPoolExecutor的执行主要分为以下两个部分:**

*  当调用ScheduledThreadPoolExecutor的scheduleAtFixedRate()方法或者scheduleWithFixedDelay()方法时，会向ScheduledThreadPoolExecutor的DelayQueue添加一个实现了RunnableScheduledFuture接口的ScheduleFutureTask。
 *  线程池中的线程从DelayQueue中获取ScheduleFutureTask，然后执行任务。

#### 4. ScheduledThreadPoolExecutor使用案例 ####

创建一个Runnable的对象，然后使用ScheduledThreadPoolExecutor的Scheduled()来执行延迟任务。

##### 4.1 延迟指定时间才开始执行schedule。 #####

public ScheduledFuture schedule(Runnable command,long delay, TimeUnit unit);

**参数解析**

*  command：实现Runnable接口的类
 *  delay：延迟多久后执行
 *  unit：用于指定keepAliveTime参数的时间单位，这是一个枚举，常用的有TimeUnit.MILLISECONDS(毫秒)，TimeUnit.SECONDS(秒)以及TimeUnit.MINUTES(分钟)等

import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @authorSaint
     * @version 1.0
     * @date 2020/8/9 15:05
     */
    public class Main {
        
    
        public static void main(String[] args) {
        
            ScheduledExecutorService scheduledThreadPoolExecutor= Executors.newScheduledThreadPool(1);
            long cur = System.currentTimeMillis();
            System.out.println("延迟要开始了");
            scheduledThreadPoolExecutor.schedule(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("Hello, World!");
                }
                //0表示首次执行任务的延迟时间，1000表示每次执行任务的间隔时间，TimeUnit.MILLISECONDS执行的时间间隔数值单位
            }, 2000, TimeUnit.MILLISECONDS);
            long stop = System.currentTimeMillis();
        }
    }

##### 4.2 周期性执行任务 #####

*  **scheduleAtFixedRate**方法的作用是预定在初始的延迟结束后，周期性地执行给定的任务，周期长度为period，其中initialDelay为初始延迟。

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                      long initialDelay,
                                                      long period,
                                                      TimeUnit unit);

*  **scheduleWithFixedDelay**方法的作用是预定在初始的延迟结束后周期性地执行给定任务，在一次调用完成和下一次调用开始之间有长度为delay的延迟，其中initialDelay为初始延迟

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                         long initialDelay,
                                                         long delay,
                                                         TimeUnit unit);

**案例代码**

package cn.com.wind.windabc.shceduledthreadpool;
    
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    /**
     * 定时任务，并增加执行次数限制
     * @author Saint
     * @version 1.0
     * @date 2020/8/9 15:14
     */
    public class ScheduledMultiThreadTool {
        
    
        private  static Integer count =1;
        MyTimerTask myTimerTask = new MyTimerTask();
        private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        ScheduledExecutorService scheduled = Executors.newScheduledThreadPool(2);
    
        public void start(){
        
            try {
        
                //一秒执行一次
                scheduled.scheduleAtFixedRate(myTimerTask, 0,1, TimeUnit.SECONDS);
                while (!scheduled.isTerminated()){
        
                    lock.readLock().lock();
                    if (count >20){
        
                        scheduled.shutdown();
                    }
                    lock.readLock().unlock();
    
                }
            }catch(Exception e){
        
                e.printStackTrace();
            }
            System.out.println("Finished all threads");
        }
        private class MyTimerTask implements Runnable {
        
            @Override
            public void run(){
        
                lock.writeLock().lock();
                System.out.println("第 "+count+ " 次执行任务,count="+count);
                count ++;
                lock.writeLock().unlock();
            }
    
        }
    
        public static void main(String[] args) {
        
            new ScheduledMultiThreadTool().start();
        }
    }

**限制程序执行的次数**：如果是单线程，那么可以直接定义一个静态变量count，每执行一次，count加一，如果count大于某个值就调用shutdown或者shutdownNow函数；如果是多线程，稍微要复杂一点，但是原理也是一样的。定义一个静态变量count，没执行一个也是count加一，只不过在执行加一操作之前需要加锁，执行完之后需要解锁  
  
  
**附：时间单位**  
毫秒：TimeUnit.MILLISECONDS  
秒：TimeUnit.SECONDS  
分钟：TimeUnit.MINUTES  
小时：TimeUnit.HOURS  
天：TimeUnit.DAYS

#### 总结 ####

SingleThreadScheduledExecutor与ScheduledThreadPoolExecutor使用方法类似。  
了解完ScheduledThreadPoolExecutor的创建方法和内置的几个schedule()方法后，使用起来还是很简单的。  
我们主要记住两个类：SingleThreadScheduledExecutor、ScheduledThreadPoolExecutor

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NhaW50bW0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200809153705626.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NhaW50bW0=,size_16,color_FFFFFF,t_70