Quartz.Net系列(十六):Misfire策略在SimpleScheduler和CronScheduler中的使用

孤人 提交于 2020-10-25 07:07:12

1.场景

①因为工作线程都在忙碌,所以导致某些Trigger得不到触发

也就是默认10个工作线程而我有15个Trigger同时触发

这就导致有5个不能被触发,而不幸的是Trigger所关联的Job执行时间特别长

如果某些Trigger超过指定的阈值那么就不会触发

②Scheduler挂掉了。。。某些时刻又恢复了

③如果你设置的时间早于现在,中有一个StartAt

2.阈值是多少

RAMJobStore默认是5s,DBJobStore是60s

为了统一阈值,在初始化的时候,会读取内置的quartz.config文件,统一设置成60s

private TimeSpan misfireThreshold = TimeSpan.FromSeconds(5);

 

quartz.jobStore.misfireThreshold = 60000

3.Misfire的策略

①错过几次让它立刻执行,后面正常调度

②错过的几次让他合并成一次执行,后面正常调度

③忽略错误的次数,正常调度

 

 

 4.SimpleScheduler怎么使用Mrsfire策略

one

IScheduler scheduler=await SchedulerBuilder.Create().Build();

            await scheduler.Start();

            var job = JobBuilder.Create<MyJob>().Build();

            var trigger = TriggerBuilder.Create()
                                        .StartAt(DateBuilder.DateOf(7,0,0))
                                        .WithSimpleSchedule(s=>
                                                               s.WithIntervalInSeconds(1)
                                                               //.WithMisfireHandlingInstructionFireNow()                                                               
                                                               )
                                        .Build();

            await scheduler.ScheduleJob(job,trigger);

repeat count

IScheduler scheduler=await SchedulerBuilder.Create().Build();

            await scheduler.Start();

            var job = JobBuilder.Create<MyJob>().Build();

            var trigger = TriggerBuilder.Create()
                                        .StartAt(DateBuilder.DateOf(7,0,0))
                                        .WithSimpleSchedule(s=>
                                                               s.WithIntervalInHours(1)
                                                               //.WithMisfireHandlingInstructionFireNow()                                                               
                                                               .WithRepeatCount(10)
                                                               .WithMisfireHandlingInstructionIgnoreMisfires()
                                                               )
                                        .Build();

            await scheduler.ScheduleJob(job,trigger);

 

 

①WithMisfireHandlingInstructionNextWithExistingCount

比如说StartTime:7:00,每小时执行一次,现在时间是10:40也就是错过了4次 ,本来是11次  7+11=18点结束

也就是下次触发的时间 StartTime:22:00开始 重复执行11次 11+11=22点结束 

也就是说任然会保留11次执行

IScheduler scheduler=await SchedulerBuilder.Create().Build();

            await scheduler.Start();

            var job = JobBuilder.Create<MyJob>().Build();

            var trigger = TriggerBuilder.Create()
                                        .StartAt(DateBuilder.DateOf(7,0,0))
                                        .WithSimpleSchedule(s=>
                                                               s.WithIntervalInHours(1)
                                                               //.WithMisfireHandlingInstructionFireNow()                                                               
                                                               .WithRepeatCount(10)
                                                               .WithMisfireHandlingInstructionNextWithExistingCount()
                                                               )
                                        .Build();

            await scheduler.ScheduleJob(job,trigger);

②WithMisfireHandlingInstructionNextWithRemainingCount

比如说StartTime:7:00,每小时执行一次,现在时间是10:40也就是错过了4次 ,本来是11次  7+11=18点结束

也就是下次触发的时间 StartTime:22:00开始 重复执行11-4次 ,不管错过的4次,正常调度,7+11=18点结束

IScheduler scheduler=await SchedulerBuilder.Create().Build();

            await scheduler.Start();

            var job = JobBuilder.Create<MyJob>().Build();

            var trigger = TriggerBuilder.Create()
                                        .StartAt(DateBuilder.DateOf(7,0,0))
                                        .WithSimpleSchedule(s=>
                                                               s.WithIntervalInHours(1)
                                                               //.WithMisfireHandlingInstructionFireNow()                                                               
                                                               .WithRepeatCount(10)
                                                               .WithMisfireHandlingInstructionNextWithRemainingCount()
                                                               )
                                        .Build();

            await scheduler.ScheduleJob(job,trigger);

③WithMisfireHandlingInstructionNowWithExistingCount

比如说StartTime:7:00,每小时执行一次,现在时间是10:40也就是错过了4次 ,本来是11次  7+11=18点结束

也就是下次触发的时间 StartTime=Now开始 重复执行11次 10.40+11=21.40结束

也就是说任然会保留11次执行,但是会从现在开始

IScheduler scheduler=await SchedulerBuilder.Create().Build();

            await scheduler.Start();

            var job = JobBuilder.Create<MyJob>().Build();

            var trigger = TriggerBuilder.Create()
                                        .StartAt(DateBuilder.DateOf(7,0,0))
                                        .WithSimpleSchedule(s=>
                                                               s.WithIntervalInHours(1)
                                                               //.WithMisfireHandlingInstructionFireNow()                                                               
                                                               .WithRepeatCount(10)
                                                               .WithMisfireHandlingInstructionNowWithExistingCount()
                                                               )
                                        .Build();

            await scheduler.ScheduleJob(job,trigger);

 

 

 ④WithMisfireHandlingInstructionNowWithRemainingCount

比如说StartTime:7:00,每小时执行一次,现在时间是10:40也就是错过了4次 ,本来是11次  7+11=18点结束

也就是下次触发的时间 StartTime=Now开始 重复执行11-4次 ,不管错过的4次,正常调度,7+10:40=17:40点结束

IScheduler scheduler=await SchedulerBuilder.Create().Build();

            await scheduler.Start();

            var job = JobBuilder.Create<MyJob>().Build();

            var trigger = TriggerBuilder.Create()
                                        .StartAt(DateBuilder.DateOf(7,0,0))
                                        .WithSimpleSchedule(s=>
                                                               s.WithIntervalInHours(1)
                                                               //.WithMisfireHandlingInstructionFireNow()                                                               
                                                               .WithRepeatCount(10)
                                                               .WithMisfireHandlingInstructionNowWithRemainingCount()
                                                               )
                                        .Build();

            await scheduler.ScheduleJob(job,trigger);

 

 

 5.Cronscheduler如何使用Misfire策略

①WithMisfireHandlingInstructionFireAndProceed

错过的合并成一次执行,不修改调度时间

也就说假如StartTime=10:00  现在时间13:16 那么将合并成一次执行 

var trigger = TriggerBuilder.Create()
                                                  .StartAt(DateBuilder.DateOf(10, 0, 0))
                                                  .WithCronSchedule("0 0 9-18 ? * MON-FRI",
                                                                    x=>x.WithMisfireHandlingInstructionFireAndProceed()
                                                                   )
                                                .Build();

 

 

②WithMisfireHandlingInstructionIgnoreMisfires

错过的立即追赶,然后正常调度

var trigger = TriggerBuilder.Create()
                                                  .StartAt(DateBuilder.DateOf(10, 0, 0))
                                                  .WithCronSchedule("0 0 9-18 ? * MON-FRI",
                                                                    x=>x.WithMisfireHandlingInstructionIgnoreMisfires()
                                                                   )
                                                .Build();

 

 

 ③WithMisfireHandlingInstructionDoNothing

错过的不管,正常执行

var trigger = TriggerBuilder.Create()
                                                  .StartAt(DateBuilder.DateOf(10, 0, 0))
                                                  .WithCronSchedule("0 0 9-18 ? * MON-FRI",
                                                                    x=>x.WithMisfireHandlingInstructionDoNothing()
                                                                   )
                                                .Build();

 

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!