精华内容
下载资源
问答
  • fixedRate

    2018-07-18 11:09:00
    fixedRate 每次任务结束后会从任务编排表中找下一次该执行的任务,判断是否到时机执行。 fixedRate 的任务某次执行时间再长也不会造成两次任务实例同时执行,除非用了 @Async 注解。 fixedDelay 总是前一次任务...

    fixedRate 每次任务结束后会从任务编排表中找下一次该执行的任务,判断是否到时机执行。

    fixedRate 的任务某次执行时间再长也不会造成两次任务实例同时执行,除非用了 @Async 注解。

    fixedDelay 总是前一次任务完成后,延时固定长度然后执行一次任务

    转载于:https://www.cnblogs.com/wanhua-wu/p/9328068.html

    展开全文
  • fixedDelay和fixedRate

    2018-08-01 15:52:50
    fixedDelay和fixedRate fixedRate: which specifies the interval between method invocations measured from the start time of each invocation. (以任务的开始时间计算) fixedDelay: which specifies the ...

    fixedDelay和fixedRate

    fixedRate: which specifies the interval between method invocations measured from the start time of each invocation. (以任务的开始时间计算)
    fixedDelay: which specifies the interval between invocations measured from the completion of the task. (以任务的完成时间计算)

    REF:

    https://spring.io/guides/gs/scheduling-tasks/#initial

    https://blog.csdn.net/u013845177/article/details/78244524

    展开全文
  • fixedRate和fixedDelay都是表示任务执行的间隔时间 fixedRate和fixedDelay的区别: fixedDelay非常好理解,它的间隔时间是根据上次的任务结束的时候开始计时的。比如一个方法上设置了fixedDelay=5*1000,那么当该...

    fixedRate和fixedDelay都是表示任务执行的间隔时间

    fixedRate和fixedDelay的区别:

    fixedDelay非常好理解,它的间隔时间是根据上次的任务结束的时候开始计时的。比如一个方法上设置了fixedDelay=5*1000,那么当该方法某一次执行结束后,开始计算时间,当时间达到5秒,就开始再次执行该方法。

    fixedRate理解起来比较麻烦,它的间隔时间是根据上次任务开始的时候计时的。比如当方法上设置了fiexdRate=5*1000,该执行该方法所花的时间是2秒,那么3秒后就会再次执行该方法。
    但是这里有个坑,当任务执行时长超过设置的间隔时长,那会是什么结果呢。打个比方,比如一个任务本来只需要花2秒就能执行完成,我所设置的fixedRate=5*1000,但是因为网络问题导致这个任务花了7秒才执行完成。当任务开始时Spring就会给这个任务计时,5秒钟时候Spring就会再次调用这个任务,可是发现原来的任务还在执行,这个时候第二个任务就阻塞了(这里只考虑单线程的情况下,多线程后面再讲),甚至如果第一个任务花费的时间过长,还可能会使第三第四个任务被阻塞。被阻塞的任务就像排队的人一样,一旦前一个任务没了,它就立马执行。

    下面用代码来具体验证一下。

    @SpringBootApplication
    @EnableScheduling
    public class ScheduledemoApplication {
    
        private AtomicInteger number = new AtomicInteger();
    
        public static void main(String[] args) {
            SpringApplication.run(ScheduledemoApplication.class, args);
        }
    
    
        @Scheduled(fixedRate = 5000 )
        public void job(){
    
            LocalTime start = LocalTime.now();
            //前面和末尾几个字符串是用来改变打印的颜色的
            System.out.println("\033[31;4m" + Thread.currentThread() + " start " + number.incrementAndGet()
                    + " @ " + start + "\033[0m");
            try {
                Thread.sleep(ThreadLocalRandom.current().nextInt(15)*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            LocalTime end = LocalTime.now();
    
            System.out.println(Thread.currentThread() + " end " + number.get() + " @ "+
                     end + ", seconds cost "+ (ChronoUnit.SECONDS.between(start, end)));
    
        }
    
    }
    

    执行结果如下:
    在这里插入图片描述
    可以看到任务第一次执行完以后还有间隔4秒才执行第二次,可是到了第二次结束的时候,就没有间隔了,直接就执行第三次了。甚至在执行第四次的时候,明明第四次任务只花费了1秒,可还是马上就执行第五次了。因为前面两次任务花费的时间太久了,有好几个被调度的任务都被阻塞了。所以当第四次一结束,马上第五次就执行了。

    @Scheduled(fixedRate)如何避免任务被阻塞
    答案是加上注解@EnableAsync(类上)和@Async(方法上),加了注解以后,就开启了多线程模式,当到了下一次任务的执行时机时,如果上一次任务还没执行完,就会自动创建一个新的线程来执行它。异步执行也可以理解为保证了任务以固定速度执行。
    开启多线程后执行结果如下:
    在这里插入图片描述
    可以看到,开启多线程后,每次任务开始的间隔都是5秒钟。这是符合我们预期的,但是最后还有点缺陷,这种情况下的线程是随着任务一执行完就销毁的,等下次有需要了程序再创建一个。每次都要重新创建明显是太影响性能了,所以需要在代码里给他一个线程池。

    创建一个线程池

    @Bean
        public TaskScheduler taskScheduler() {
            ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
            taskScheduler.setPoolSize(5);
            return taskScheduler;
        }
    

    在这里插入图片描述
    可以看到现在程序就不会再自己创建线程了,每次都会从线程池里面拿。需注意的是,如果线程池里的所有线程都被拿去执行调度任务了,且又到了时间要执行一次任务,那么这个任务又会被阻塞。所以实际开发中如果想要保证任务以速度被执行,线程池的最大线程数量可要想好。

    话说真的要深入理解的话其实还得看源码,这些测试只是通过表象来猜测。
    over

    展开全文
  • 用过 Spring 的 @EnableScheduling 的都知道,我们用三种形式来部署计划任务,即 @Scheduled 注解的 fixedRate(fixedRateString), fixedDelay(fixedDelayString), 以及 cron. cron 不在这里讨论的范畴。  我们着重...
    
     
    •  
    • // cron expression 自定义规则

    • // 参数顺序

    • // 秒 分 时 日 月 星期

    • // "0 0 * * * *" = the top of every hour of every day.

    • // "*/10 * * * * *" = every ten seconds.

    • // "0 0 8-10 * * *" = 8, 9 and 10 o'clock of every day.

    • // "0 0 6,19 * * *" = 6:00 AM and 7:00 PM every day.

    • // "0 0/30 8-10 * * *" = 8:00, 8:30, 9:00, 9:30, 10:00 and 10:30 every day.

    • // "0 0 9-17 * * MON-FRI" = on the hour nine-to-five weekdays

    • // "0 0 0 25 12 ?" = every Christmas Day at midnight

    •  
    • /**

    • * 10秒执行一次

    • */

    • @Scheduled(cron="0/10 * * * * *")

    • -----------------------------------------------------------------------------------------------

     

    用过  Spring 的 @EnableScheduling 的都知道,我们用三种形式来部署计划任务,即 @Scheduled 注解的 fixedRate(fixedRateString), fixedDelay(fixedDelayString), 以及 cron. cron 不在这里讨论的范畴。

      我们着重在如何理解 fixedRate 和 fixedDelay 的区别。

      在 Spring 的  Scheduled 注解的 JavaDoc 对此的解释很简单

    public abstract long fixedRate 
    Execute the annotated method with a fixed period in milliseconds between invocations.
    
    public abstract long fixedDelay 
    Execute the annotated method with a fixed period in milliseconds between the end of the last invocation and the start of the next.

      只是说是 fixedRate 任务两次执行时间间隔是任务的开始点,而 fixedDelay 的间隔是前次任务的结束与下次任务的开始。

      大致用示意字符串来表示如下(每个 T1, 或 T2 代表任务执行秒数(每次任务执行时间不定),假定 fixedRate 或  fixedDelay 的值是 5 秒,用 W 表示等待的数)

     

      fixedRate:    T1.T1WWWT2.T2.T2WW.T3.T3.T3.T3.T3.T4.T4.T4.T4.T4.T4.T4T5T5WWWT6.T6........

     

      fixedDelay:  T1.T1.WWWWW.T2.T2.T2WWWWW.T3.T3.T3.T3.T3.WWWWW.T4.T4.T4.T4.T4.T4.T4.WWWWWT6.T6......

      一般来说能理解到上面两个场景已经差不多了,相比而言 fixedDelay 简单些,盯着上一次任务的屁股就行。

     

      以前我对 fixedRate 还有一个误区就是,以为任务时长超过 fixedRate 时会启动多个任务实例,其实不会; 只不过会在上次任务执行完后立即启动下一轮。除非这个 Job 方法用 @Async 注解了,使得任务不在 TaskScheduler 线程池中执行,而是每次创建新线程来执行。

      具体理解我们可以用代码来演示

    复制代码

    @EnableScheduling
    @SpringBootApplication
    public class Application {
     
        private AtomicInteger number = new AtomicInteger();
     
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
     
        @Bean
        public TaskScheduler taskScheduler() {
            ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
            taskScheduler.setPoolSize(5);
            return taskScheduler;
        }
     
        @Scheduled(fixedRate = 5000)
        public void job() {
            LocalTime start = LocalTime.now();
            System.out.println(Thread.currentThread() + " start " + number.incrementAndGet() + " @ "  + start);
            try {
                Thread.sleep(ThreadLocalRandom.current().nextInt(15) * 1000);
            } catch (InterruptedException e) {
            }
            LocalTime end = LocalTime.now();
            System.out.println(Thread.currentThread() + " end " + number.get() + " @ " + end
                + ", seconds cost " + (ChronoUnit.SECONDS.between(start, end)));
        }
    }

    复制代码

      初始化了一个线程池大小为 5  的 TaskScheduler, 避免了所有任务都用一个线程来执行。 上例中的 fixedRate 为 5 秒,任务执行时间在 0 ~ 15 秒之间,先来看一组数据(样本数据越多越生动)

    复制代码

    Thread[taskScheduler-1,5,main] start 1 @ 01:23:11.726
    Thread[taskScheduler-1,5,main] end 1 @ 01:23:24.732, seconds cost 13
    Thread[taskScheduler-1,5,main] start 2 @ 01:23:24.736
    Thread[taskScheduler-1,5,main] end 2 @ 01:23:28.737, seconds cost 4
    Thread[taskScheduler-2,5,main] start 3 @ 01:23:28.738
    Thread[taskScheduler-2,5,main] end 3 @ 01:23:40.739, seconds cost 12
    Thread[taskScheduler-1,5,main] start 4 @ 01:23:40.740
    Thread[taskScheduler-1,5,main] end 4 @ 01:23:52.745, seconds cost 12
    Thread[taskScheduler-3,5,main] start 5 @ 01:23:52.745
    Thread[taskScheduler-3,5,main] end 5 @ 01:24:00.748, seconds cost 8
    Thread[taskScheduler-3,5,main] start 6 @ 01:24:00.749
    Thread[taskScheduler-3,5,main] end 6 @ 01:24:05.750, seconds cost 5
    Thread[taskScheduler-3,5,main] start 7 @ 01:24:05.750
    Thread[taskScheduler-3,5,main] end 7 @ 01:24:05.750, seconds cost 0
    Thread[taskScheduler-3,5,main] start 8 @ 01:24:05.750
    Thread[taskScheduler-3,5,main] end 8 @ 01:24:14.752, seconds cost 9
    Thread[taskScheduler-3,5,main] start 9 @ 01:24:14.752
    Thread[taskScheduler-3,5,main] end 9 @ 01:24:26.756, seconds cost 12
    Thread[taskScheduler-3,5,main] start 10 @ 01:24:26.757
    Thread[taskScheduler-3,5,main] end 10 @ 01:24:39.757, seconds cost 13
    Thread[taskScheduler-3,5,main] start 11 @ 01:24:39.757
    Thread[taskScheduler-3,5,main] end 11 @ 01:24:43.761, seconds cost 4
    Thread[taskScheduler-3,5,main] start 12 @ 01:24:43.762
    Thread[taskScheduler-3,5,main] end 12 @ 01:24:47.763, seconds cost 4
    Thread[taskScheduler-3,5,main] start 13 @ 01:24:47.763
    Thread[taskScheduler-3,5,main] end 13 @ 01:24:49.766, seconds cost 2
    Thread[taskScheduler-3,5,main] start 14 @ 01:24:49.767

    复制代码

    把 start 行用红色显示。

    1. 任务 1 与 2 之间间隔时间是任务时长 13,所以任务 2 在 1 结束后立即启动
    2. 任务 3 与 2 之间间隔还不到 5 秒,也是在任务 2 结束后立即执行
    3. 后面都是在上次任务结束后立即执行下一次任务,看到 7 与 8 之间相差 0 秒,13 与 14 之间相关 2 秒

    从上面的结果分析,似乎 fixedRate 越到后面都不起作用,总是任务一个接一个的执行。也就是说上面 fixedRate 的示意串

    T1.T1WWWT2.T2.T2WW.T3.T3.T3.T3.T3.T4.T4.T4.T4.T4.T4.T4T5T5WWWT6.T6........

    已经不成立了,当中间发生了一长时间的任务后,fixedRate 变成了如下的形式

    T1.T1.WWWT2.T2.T2.T2.T2.T2.T2.T2.T2.T2.T2.T2.T3.T3.T3.T3.T4.T4.T4.T5.T5.T5.......

      任务间的等待都被抹除掉了,这是为什么呢?因为 fixedRate 会对将要执行的任务作一个预先编排,由上输出可以第一次任务在 01:23:11 时间点启动,所以  fixedRate 会基于此把一个时间表准备好,如下

    01:23:16 T2 T1 执行后时间来到了 01:23:24, 下一次任务 T2 安排在更早的时间,所以立即执行 T2
    01:23:21 T3 T2 完后时间是 01:23:28, T3 的安排时间也比它早,所以也是立即执行 T3
    01:23:26 T4 T3 完后时间是 01:23:40, 无需等待立即执行 T4
    01:23:31 T5

    后面的情况都是一样的, T5.endTime > T6.scheduledTime + fixedRate, 所以立即执行 T6 

    除非有一些短任务能把时间压缩回去,造成上一次任务结束后需要进行等待

    01:23:35 T6
    01:23:41 T7

       因此,fixedRate 总是在上一次任务结束后从时间表中挑出下一次任务,对比该任务所预先排好的时间是否晚于上次任务启动时间加上 fixedRate 值,是则等待到预定的时间,否则立即执行。

      假设 T1 执行完后时间是 T1.endTime, 这时候判断 T1.endTime < T2.scheduledTime + fixedRate,  是则等待到 T2.scheduledTime 启动 T2, 否则立即执行  T2

      我们可以用代码进一步来验证上面的说法,其实最具说服力的莫过于源代码,这里只提供感观体验

      代码的改动是第一次任务执行时间为 23  秒,此后的任务是不耗时的空操作

    复制代码

     private AtomicBoolean firstTime = new AtomicBoolean(true);
     
        @Scheduled(fixedRate = 5000)
        public void job() {
            LocalTime start = LocalTime.now();
            System.out.println(Thread.currentThread() + " start " + number.incrementAndGet() + " @ "  + start);
            if (firstTime.getAndSet(false)) {
                try {
                    Thread.sleep(23000);
                } catch (InterruptedException e) {
                }
            }
            LocalTime end = LocalTime.now();
            System.out.println(Thread.currentThread() + " end " + number.get() + " @ " + end
                + ", seconds cost " + (ChronoUnit.SECONDS.between(start, end)));
        }

    复制代码

      输出为

    复制代码

    Thread[taskScheduler-1,5,main] start 1 @ 03:27:54.556
    Thread[taskScheduler-1,5,main] end 1 @ 03:28:17.562, seconds cost 23
    Thread[taskScheduler-1,5,main] start 2 @ 03:28:17.566
    Thread[taskScheduler-1,5,main] end 2 @ 03:28:17.566, seconds cost 0
    Thread[taskScheduler-2,5,main] start 3 @ 03:28:17.566
    Thread[taskScheduler-2,5,main] end 3 @ 03:28:17.567, seconds cost 0
    Thread[taskScheduler-1,5,main] start 4 @ 03:28:17.584
    Thread[taskScheduler-1,5,main] end 4 @ 03:28:17.584, seconds cost 0
    Thread[taskScheduler-4,5,main] start 5 @ 03:28:17.584
    Thread[taskScheduler-4,5,main] end 5 @ 03:28:17.584, seconds cost 0
    Thread[taskScheduler-4,5,main] start 6 @ 03:28:19.549
    Thread[taskScheduler-4,5,main] end 6 @ 03:28:19.550, seconds cost 0
    Thread[taskScheduler-4,5,main] start 7 @ 03:28:24.549
    Thread[taskScheduler-4,5,main] end 7 @ 03:28:24.550, seconds cost 0
    Thread[taskScheduler-4,5,main] start 8 @ 03:28:29.548
    Thread[taskScheduler-4,5,main] end 8 @ 03:28:29.549, seconds cost 0
    Thread[taskScheduler-4,5,main] start 9 @ 03:28:34.546

    复制代码

      因为第一次任务 23 秒的延误,所以后续的任务 2, 3, 4, 5 都是上次任务(耗时为 0)完后立即执行,任务 6 把 2 秒的差距找回来了,以后都是每隔 5 秒执行一次。

      fixedDelay 的逻辑就相当简单了,基本无需用代码来演示。不妨把上面的代码中的 fixedRate 改成 fixedDelay 来一见分晓:

     

    Thread[taskScheduler-1,5,main] start 1 @ 02:54:33.750
    Thread[taskScheduler-1,5,main] end 1 @ 02:54:43.756, seconds cost 10
    Thread[taskScheduler-1,5,main] start 2 @ 02:54:48.765
    Thread[taskScheduler-1,5,main] end 2 @ 02:55:00.767, seconds cost 12
    Thread[taskScheduler-2,5,main] start 3 @ 02:55:05.769
    Thread[taskScheduler-2,5,main] end 3 @ 02:55:11.772, seconds cost 6
    Thread[taskScheduler-1,5,main] start 4 @ 02:55:16.775
    Thread[taskScheduler-1,5,main] end 4 @ 02:55:21.781, seconds cost 5
    Thread[taskScheduler-3,5,main] start 5 @ 02:55:26.785
    Thread[taskScheduler-3,5,main] end 5 @ 02:55:27.787, seconds cost 1
    Thread[taskScheduler-3,5,main] start 6 @ 02:55:32.789
    Thread[taskScheduler-3,5,main] end 6 @ 02:55:41.792, seconds cost 9
    Thread[taskScheduler-3,5,main] start 7 @ 02:55:46.794

     

      总是上次任务结束 5 秒后,由此可见 fixedDelay 不存在任务的预先编排操作了,都是相机而为。

      最后小结一下:fixedRate 每次任务结束后会从任务编排表中找下一次该执行的任务,判断是否到时机执行。fixedRate 的任务某次执行时间再长也不会造成两次任务实例同时执行,除非用了 @Async 注解。 fixedDelay 总是前一次任务完成后,延时固定长度然后执行一次任务

     

      本文来自于: https://unmi.cc/understand-spring-schedule-fixedrate-fixeddelay/, 来自 隔叶黄莺 Unmi Blog

     

    展开全文
  • 转载:@Schedule中关于fixedDelay和fixedRate的区别
  • spring定时器fixedRate的简述

    万次阅读 2017-02-10 09:30:47
    @Scheduled(fixedRate = 5000) 这个注解在容器启动时便会生效,5秒执行一次任务.如果第一次任务时间为7秒从10:00执行到10:07,那么第二次任务为2秒的话,则从10:07执行到10:10(其中1秒为任务的轮询时间). 如果第一次...
  • 用过 Spring 的 @EnableScheduling 的都知道,我们用三种形式来部署计划任务,即 @Scheduled 注解的 fixedRate(fixedRateString), fixedDelay(fixedDelayString), 以及 cron. cron 不在这里讨论的范畴。我们着重在...
  • fixedRate 下一次程序执行的时间 @Async //人体红外读取方法 @Scheduled(initialDelay = 4000 * 600, fixedRate = 4000 * 600)//每40分钟人体红外读取方法 public void redOf() { InfraredOfhumanBody(); } //...
  • @Scheduled注解可以控制方法定时执行,...2、fixedRate是按照一定的速率执行,是从上一次方法执行开始的时间算起,如果上一次方法阻塞住了,下一次也是不会执行,但是在阻塞这段时间内累计应该执行的次数,当不再阻...
  • 其实很简单很简单一两句话就能把fixedRate和fixedDelay的区别解释的一清二楚: fixedRate=5000:下一次任务的开始时间是这一次开始的时间+5秒 fixedDelay=5000:下一次任务的开始时间是这一次开始的时间+这一次...
  • Spring Task定时任务之详解cron fixedDelay fixedRate背景介绍Spring Task区别 背景介绍 Spring非常强大,自带了Spring Task任务调度框架,基本能满足日常需求。比之更全面的框架还有quartz。相对的,学习成本也更高...
  • fixedRate和fixedDelay都是表示任务执行的间隔时间 fixedRate和fixedDelay的区别: fixedDelay非常好理解,它的间隔时间是根据上次的任务结束的时候开始计时的。比如一个方法上设置了fixedDelay=5*1000,那么当该...
  • spring注解@Scheduled中fixedDelay、fixedRate和cron表达式的区别
  • 对比就可以看出差距,fixedRate 是忽视任务的执行时间的,以固定的时间间隔(速率)启动任务去执行。而fixedDelay关心什么任务时候结束,结束了再加上配置的时间间隔去执行 initialDelay : 服务启动后立即延迟...
  • } @Scheduled(fixedRate = 4000) public void testFixedRate() throws Exception { log.info("开始 fixedRate test ---------"); } @Scheduled(fixedDelay = 4000L) public void testFixedDelay() throws ...
  • 1.cron --@Scheduled(cron=“0/5 * * * *?”) 当时间达到设置的时间会触发事件。上面那个例子会每5秒执行一次。 2018/1/4 14:27:30 2018/1/4 14:27:35 ...2.fixedRate --@Scheduled(fixedRate=...
  • springboot的Scheduled定时器 springboot的fixedDelay和fixedRate区别
  • @Scheduled中fixedDelay、fixedRate、initialDelay 和cron表达式的解析及区别 原文链接:https://blog.csdn.net/qq_34129814/article/details/85090162 一、 在线Cron表达式生成器 http://cron.qqe2.com/ 二、...
  • Spring @Scheduled定时任务的fixedRate,fixedDelay,cron执行差异import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date; import org.springframework.scheduling.annotation....
  • fixedRate是按照一定的速率执行,是从上一次方法执行开始的时间算起,如果上一次方法阻塞住了,下一次也是不会执行,但是在阻塞这段时间内累计应该执行的次数,当不再阻塞时,一下子把这些全部执行掉,而后再按照...
  • Spring定时任务@Scheduled注解使用配置方式(cron表达式、fixedRate和fixedDelay) 序言: 个人推荐一个很方便的在线Cron生成器(网页版):https://qqe2.com/cron/index 一、前言 spring的@Scheduled定时...
  • 2、fixedRate是按照一定的速率执行,是从上一次方法执行开始的时间算起,如果上一次方法阻塞住了,下一次也是不会执行, 但是在阻塞这段时间内累计应该执行的次数,当不再阻塞时,一下子把这些...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 437
精华内容 174
关键字:

fixedrate