Quartz.Net系列（十六）：Misfire策略在SimpleScheduler和CronScheduler中的使用

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();

来源：oschina

链接：https://my.oschina.net/u/4408611/blog/4393031

标签

quartz.net

quartz