定时任务-Quartz-Trigger

存在,及合理

于 2024-06-30 11:17:17 发布

阅读量984

点赞数 28

分类专栏：分布式解决方案文章标签： wpf java 分布式

本文链接：https://blog.csdn.net/qq_26594041/article/details/140077820

版权

分布式解决方案专栏收录该内容

12 篇文章 0 订阅

订阅专栏

实现

SimpleTrigger：简单触发器，支持定义任务执行的间隔时间，执行次数的规则有两种，一是定义重复次数，二是定义开始时间和结束时间。如果同时设置了结束时间与重复次数，先结束的会覆盖后结束的，以先结束的为准。
CronTrigger：基于Cron表达式的触发器。
CalendarIntervalTrigger：基于日历的触发器，比简单触发器更多时间单位，且能智能区分大小月和平闰年。
DailyTimeIntervalTrigger：基于日期的触发器，如每天的某个时间段。

状态

表

Quartz自带的表里面

triggers表。triggers表里记录了，某个trigger的PREV_FIRE_TIME（上次触发时间），NEXT_FIRE_TIME（下一次触发时间），TRIGGER_STATE（当前状态）。虽未尽述，但是本文用到的只有这些。
locks表。Quartz支持分布式，也就是会存在多个线程同时抢占相同资源的情况，而Quartz正是依赖这张表，处理这种状况
fired_triggers表，记录正在触发的triggers信息。

属性

jobKey属性∶当trigger触发时被执行的job的身份，可停止某个key的定时任务
startTime属性∶设置trigger第一次触发的时间; startNow() 立即执行
endTime属性∶表示trigger失效的时间点
优先级（priority）同时执行，并且工作线程数少于trriger数
错过触发（misfire Instructions）
日历示例（calendar）

优先级

@PersistJobDataAfterExecution
public class Myjob implements Job {

    @Setter@Getter
    private  int count;
    @SneakyThrows
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime now = LocalDateTime.now();
        count++;
        context.getJobDetail().getJobDataMap().put("count",count);
        System.out.println(count);
        Thread.sleep(1000);
    }
}

public class TrigerPriorityTest {
    public static void main(String[] args) {
        String ss="0/2 * * * * ? *";
        try {
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

            JobDetail jobDetail1 = JobBuilder.newJob(MyJobDemo.class).withIdentity("test1", "Tests")
            .withDescription("初次测试")
            .usingJobData("count",1)
            .build();

            JobDetail jobDetail2 = JobBuilder.newJob(MyJobDemo.class).withIdentity("test", "Tests")
            .withDescription("初次测试")
            .usingJobData("count",2)
            .build();

            Date date = DateBuilder.futureDate(15, DateBuilder.IntervalUnit.SECOND);

            Trigger simpleTrigger1 = TriggerBuilder.newTrigger()
            .withDescription("测试触发器")
            .withPriority(4)
            .startAt(date)
            .withSchedule(CronScheduleBuilder.cronSchedule(ss))
            .build();

            Trigger simpleTrigger2 = TriggerBuilder.newTrigger()
            .withDescription("测试触发器")
            .withPriority(9)
            .startAt(date)
            .withSchedule(CronScheduleBuilder.cronSchedule(ss))
            .build();

            scheduler.scheduleJob(jobDetail1,simpleTrigger1);
            scheduler.scheduleJob(jobDetail2,simpleTrigger2);
            scheduler.start();

            TimeUnit.SECONDS.sleep(50);

        } catch (SchedulerException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

SimpleTrigger

可以具体时间点执行一次
可以按照指定间隔时间重复若干次
重要属性：开始时间、结束时间、重复次数、重复间隔
重复次数：0、正整数、无限次执行
重复间隔：0（并发执行）、long型（毫秒级）

@Getter
@Slf4j
public class MyJobDemo implements Job {

    @Setter
    private  int count;
    @SneakyThrows
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime now = LocalDateTime.now();

        //获取参数
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        Date nextFireTime = context.getNextFireTime();
        jobDataMap.forEach((k,v)->{
            log.info("k{},v{}",k,v);
        });

        //更新参数
        count++;
        context.getJobDetail().getJobDataMap().put("count",count);
        log.info(String.valueOf(count));
    }
}

withIntervalInSeconds，有许多的时间单位

@Configuration
public class QuartzConfig {

    @Bean
    public JobDetail myJobDetail() {
        return JobBuilder.newJob(MyJobDemo.class)
                .withIdentity("SpringBoot2", "SpringBoot")
                .usingJobData("du", "ruilong")
                .storeDurably()
                .build();
    }

    @Bean
    public Trigger myTriger() {
        return TriggerBuilder.newTrigger()
                .withIdentity("sp2", "sp2")
                .withPriority(10)
                .startNow()
                .forJob(myJobDetail())
                .withSchedule(SimpleScheduleBuilder
                        .simpleSchedule()
                        .repeatForever()
                        .withIntervalInSeconds(3)
                ).build();
    }
}

CronTrigger

.withSchedule(CronScheduleBuilder.cronSchedule(ss))

MisFire

public class MisFireTest {
    public static void main(String[] args) {
        try {
            /**
             * 读取配置文件
             */
            Scheduler sc = StdSchedulerFactory.getDefaultScheduler();
            JobDetail build = JobBuilder.newJob(MyjobMisfire.class).storeDurably()
            .withIdentity("测试错误补偿", "补偿组")
            .usingJobData("bu", "chang")
            .withDescription("测试补偿的组")
            .build();
            CronTrigger cronTrigger = TriggerBuilder.newTrigger()
            .withIdentity("测试错误补偿", "补偿组")
            .withSchedule(
                CronScheduleBuilder.cronSchedule("0/5 * * * * ? *")
                .withMisfireHandlingInstructionIgnoreMisfires()
                .withMisfireHandlingInstructionFireAndProceed()
                //.withMisfireHandlingInstructionDoNothing()
            )
            .startNow()
            .build();
            sc.scheduleJob(build,cronTrigger);
            sc.start();

        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

public class TriggrtListerTest {
    public static void main(String[] args) {
        try {

            Scheduler sc = StdSchedulerFactory.getDefaultScheduler();
            JobDetail build = JobBuilder.newJob(MyjobMisfire.class).storeDurably()
                    .withIdentity("触发器", "触发器组")
                    .usingJobData("bu", "chang")
                    .withDescription("测试触发器的组")
                    .build();
            CronTrigger cronTrigger = TriggerBuilder.newTrigger()
                    .withIdentity("触发器监听器", "触发器组")
                    .withSchedule(
                            CronScheduleBuilder.cronSchedule("0/5 * * * * ? *")
                    )
                    .startNow()
                    .build();
            sc.getListenerManager().addTriggerListener(new MyTriggerListener());
            sc.scheduleJob(build,cronTrigger);
            sc.start();

        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

全局策略

MISFIRE_INSTRUCTION_SMART_POLICY

所有的Trigger的MisFire默认值都是这个，大致意思是“把处理逻辑交给聪明的Quartz去决定”。

基本策略是，

如果是只执行一次的调度，使用MISFIRE_INSTRUCTION_FIRE_NOW

如果是无限次的调度(repeatCount是无限的)，使用

MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT

否则，使用

MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT

MISFIRE_INSTRUCTION_FIRE_NOW

忽略已经MisFire的任务，并且立即执行调度。这通常只适用于只执行一次的任务。

MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT

将startTime设置当前时间，立即重新调度任务，包括的MisFire的

MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_REMAINING_REPEAT_COUNT

类似MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT，区别在于会忽略已经MisFire的任务

MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT

在下一次调度时间点，重新开始调度任务，包括的MisFire的

MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT

类似于MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT，区别在于会忽略已经MisFire的任务。

MISFIRE_INSTRUCTION_SMART_POLICY

所有的Trigger的MisFire默认值都是这个，大致意思是“把处理逻辑交给聪明的Quartz去决定”。

基本策略是，

如果是只执行一次的调度，使用MISFIRE_INSTRUCTION_FIRE_NOW

如果是无限次的调度(repeatCount是无限的)，使用

MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT

否则，使用

MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT

withMisfireHandlingInstructionFireAndProceed

错过立即执行

CronTrigger

withMisfireHandlingInstructionDoNothing

不触发立即执行

等待下次Cron触发频率到达时刻开始按照Cron频率依次执行

错过的时间小于设置的时间5秒，还是会补偿执行

org.quartz.jobStore.misfireThreshold=1000 错过则不执行

CronTrigger cronTrigger = TriggerBuilder.newTrigger()
        .withIdentity("测试错误补偿", "补偿组")
        .withSchedule(
                CronScheduleBuilder.cronSchedule("0/5 * * * * ? *")
                        .withMisfireHandlingInstructionDoNothing()
        )
        .startNow()
        .build();