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

quartz.jobStore.misfireThreshold =

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

                                        .WithSimpleSchedule(s=>

                                                               s.WithIntervalInSeconds()

                                                               //.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(,,))

                                        .WithSimpleSchedule(s=>

                                                               s.WithIntervalInHours()

                                                               //.WithMisfireHandlingInstructionFireNow()

                                                               .WithRepeatCount()

                                                               .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(,,))

                                        .WithSimpleSchedule(s=>

                                                               s.WithIntervalInHours()

                                                               //.WithMisfireHandlingInstructionFireNow()

                                                               .WithRepeatCount()

                                                               .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(,,))

                                        .WithSimpleSchedule(s=>

                                                               s.WithIntervalInHours()

                                                               //.WithMisfireHandlingInstructionFireNow()

                                                               .WithRepeatCount()

                                                               .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(,,))

                                        .WithSimpleSchedule(s=>

                                                               s.WithIntervalInHours()

                                                               //.WithMisfireHandlingInstructionFireNow()

                                                               .WithRepeatCount()

                                                               .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(,,))

                                        .WithSimpleSchedule(s=>

                                                               s.WithIntervalInHours()

                                                               //.WithMisfireHandlingInstructionFireNow()

                                                               .WithRepeatCount()

                                                               .WithMisfireHandlingInstructionNowWithRemainingCount()

                                                               )

                                        .Build();

            await scheduler.ScheduleJob(job,trigger);

5.Cronscheduler如何使用Misfire策略

①WithMisfireHandlingInstructionFireAndProceed

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

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

            var trigger = TriggerBuilder.Create()

                                                  .StartAt(DateBuilder.DateOf(, , ))

                                                  .WithCronSchedule("0 0 9-18 ? * MON-FRI",

                                                                    x=>x.WithMisfireHandlingInstructionFireAndProceed()

                                                                   )

                                                .Build();

②WithMisfireHandlingInstructionIgnoreMisfires

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

            var trigger = TriggerBuilder.Create()

                                                  .StartAt(DateBuilder.DateOf(, , ))

                                                  .WithCronSchedule("0 0 9-18 ? * MON-FRI",

                                                                    x=>x.WithMisfireHandlingInstructionIgnoreMisfires()

                                                                   )

                                                .Build();

③WithMisfireHandlingInstructionDoNothing

错过的不管，正常执行

          var trigger = TriggerBuilder.Create()

                                                  .StartAt(DateBuilder.DateOf(, , ))

                                                  .WithCronSchedule("0 0 9-18 ? * MON-FRI",

                                                                    x=>x.WithMisfireHandlingInstructionDoNothing()

                                                                   )

                                                .Build();