ScheduledThreadPoolExecutor 中ScheduleAtFixedRate 和 ScheduleWithFixedDelay方法讲解

﹏ヽ暗。殇╰゛Y 2023-09-30 23:19 7阅读 0赞

java 中ScheduledExecutorService接口是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。  
其中的一个实现类是ScheduledThreadPoolExecutor，ScheduledThreadPoolExecutor的uml类图关系如下：

![这里写图片描述][SouthEast]

(1)>ScheduledThreadPoolExecutor实现ScheduledExecutorService接口，实现了一些定时任务处理的方法。

(2)>ScheduledThreadPoolExecutor继承了ThreadPoolExecutor，可以通过线程池进行任务的管理和调度。

下面介绍ScheduledThreadPoolExecutor中实现ScheduledExecutorService接口最常用的调度的两个方法ScheduleAtFixedRate 和 ScheduleWithFixedDelay。

一、scheduleAtFixedRate方法  
1：方法简介

scheduleAtFixedRate(Runnable command,
                                    long initialDelay,
                                      long period,
                                      TimeUnit unit)

上面的四个参数进行讲解：  
第一个command参数是任务实例，  
第二个initialDelay参数是初始化延迟时间，  
第三个period参数是间隔时间，  
第四个unit参数是时间单元。

2：代码实例  
（1）：当任务实例commod执行的时间小于间隔时间period情况

public class TestExecutor {
        
    
        private static  ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
    
        public static void main(String[] args) {
        
    
    
        }
    
        /**
         *  进行scheduleAtFixedRate测试
         */
        public static void testFixedRate(){
        
            executor.scheduleAtFixedRate(new myRun(), 5, 5, TimeUnit.SECONDS);
        }
    
    
        static class myRun implements Runnable{
        
    
            @Override
            public void run() {
        
                System.out.println("----测试开始--------"+ new Date().toLocaleString());
                try {
        
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
        
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("---休眠3秒后, 处理结束--------"+new Date().toLocaleString());
            }
        }
    
    }

运行结果：

----测试开始--------2017-10-11 11:38:38  #第一次执行
    ---休眠3秒后, 处理结束--------2017-10-11 11:38:41  #第一次任务处理，花费3秒
     #第二次执行时间是第一次时间 + period 即38 + 5 = 43；
    ----测试开始--------2017-10-11 11:38:43 
    ---休眠3秒后, 处理结束--------2017-10-11 11:38:46
    ----测试开始--------2017-10-11 11:38:48
    ---休眠3秒后, 处理结束--------2017-10-11 11:38:51
    ----测试开始--------2017-10-11 11:38:53

（2）：当任务实例commod执行的时间大于间隔时间period情况  
修改 Thread.sleep(3000); 为 Thread.sleep(6000);，执行查看运行结果！

运行结果：

----测试开始--------2017-10-11 11:41:22 #第一次执行时间
    ---休眠3秒后, 处理结束--------2017-10-11 11:41:28 # 任务处理6秒，即 22+6 = 28
    #第二次执行时间 == 上一次处理结束时间，因为任务处理时间大于period间隔时间
    ----测试开始--------2017-10-11 11:41:28 
    ---休眠3秒后, 处理结束--------2017-10-11 11:41:34
    ----测试开始--------2017-10-11 11:41:34

3：总结  
ScheduleAtFixedRate 每次执行时间为上一次任务开始起向后推一个时间间隔。分为两种情况：  
（1）若command执行的时间小于period若每次执行时间为 :initialDelay, initialDelay+period, initialDelay+2\*period, …；

（2）若command执行的时间大于period，则command执行完，下一次任务将立即执行！下即下一次任务不会按照预期的时间间隔执行，每次执行时间为 :initialDelay, initialDelay+taskExecutorTIme, initialDelay+2\*taskExecutorTIme, …；

taskExecutorTIme为任务执行的时间！

二、scheduleWithFixedDelay

1：方法简介

scheduleWithFixedDelay(Runnable command,
                                                         long initialDelay,
                                                         long delay,
                                                         TimeUnit unit

上面的四个参数进行讲解：  
第一个command参数是任务实例，  
第二个initialDelay参数是初始换延迟时间，  
第三个delay参数是延迟间隔时间，  
第四个unit参数是时间单元

2：代码实例

（1）：当任务实例commod执行的时间小于延迟间隔时间delay情况

public class TestExecutor {
        
    
        private static  ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
    
        public static void main(String[] args) {
        
            testFixedDelay();
    
        }
    
    
    
    
        public static void testFixedDelay(){
        
            executor.scheduleWithFixedDelay(new myRun(), 5, 5, TimeUnit.SECONDS);
        }
    
    
        static class myRun implements Runnable{
        
    
            @Override
            public void run() {
        
                System.out.println("----测试开始--------"+ new Date().toLocaleString());
                try {
        
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
        
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("---休眠3秒后, 处理结束--------"+new Date().toLocaleString());
            }
        }
    
    
    }

运行结果：

----测试开始--------2017-10-11 11:59:02 #第一次执行时间
    ---休眠3秒后, 处理结束--------2017-10-11 11:59:05 #任务处理的时间，3秒
    #第二次执行的时间 == 第一次任务开始时间+任务处理时间+delay延迟时间
    #即 10 == 02 + 3秒 +  5秒 
    ----测试开始--------2017-10-11 11:59:10
    ---休眠3秒后, 处理结束--------2017-10-11 11:59:13
    ----测试开始--------2017-10-11 11:59:18
    ---休眠3秒后, 处理结束--------2017-10-11 11:59:21

（2）：当任务实例commod执行的时间大于延迟间隔时间delay情况  
将Thread.sleep(3000); 修改为 Thread.sleep(6000);  
运行结果：

----测试开始--------2017-10-11 12:02:48 #第一次任务执行开始时间
    ---休眠6秒后, 处理结束--------2017-10-11 12:02:54  #任务处理的时间 ，6秒
    #第二次任务执行开始时间 == 第一次任务执行开始时间 + 任务处理的时间 + delay延迟时间
    #即 59 == 48 + 6 + 5 
    ----测试开始--------2017-10-11 12:02:59
    ---休眠6秒后, 处理结束--------2017-10-11 12:03:05
    ----测试开始--------2017-10-11 12:03:10

3：总结  
不管任务command执行的时间是多长，下一次任务的执行时间都是上一次任务执行完后在等待延迟间隔delay时间后执行下一次任务。  
ScheduleWithFixedDelay 每次执行时间为上一次任务结束起向后推一个时间间隔，即每次执行时间为：initialDelay, initialDelay+executeTime+delay, initialDelay+2*executeTime+2*delay。

**参考**  
https://www.ibm.com/developerworks/cn/java/j-lo-taskschedule/

[SouthEast]: https://img-blog.csdn.net/20171011112906359?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvdTAxMDY0ODU1NQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast