Quartz总结

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Quartz总结相关的知识,希望对你有一定的参考价值。

前言

最近项目中有使用到Quartz,得空便总结总结,顺便记录一下这种设计模式,毕竟“好记性不如烂笔头”。

搭建

pom文件:

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.2.3</version>
</dependency>

quartz.properties配置:

org.quartz.scheduler.instanceName = MyScheduler
org.quartz.threadPool.threadCount = 3
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

简单的示例

EnumCheckJobType,任务类型

public enum EnumCheckJobType {

    ONE,TWO
    
}

SchedulerTask,任务的接口

public interface SchedulerTask {

    void run();

}

OneScheduler,一个具体的任务

public class OneScheduler implements SchedulerTask{

    @Override
    public void run() {
        //do something
    }
}

 

TwoScheduler,另一个具体的任务

ublic class TwoScheduler implements SchedulerTask{

    @Override
    public void run() {
        //do something
    }
}

MyJob,执行任务(必须实现Job接口)

public class MyJob implements Job {

    @Override
    public void execute(JobExecutionContext jobExecutionContext) {
        
        SchedulerTask task = (SchedulerTask) jobExecutionContext.getMergedJobDataMap().get("task");
        task.run();     
    }  
}

MyScheduler,调度器(什么时候执行什么任务,指的是MyJob的execute方法)

public class MyScheduler {

    /**
     * 注册调度任务
     *
     * @param scheduler
     * @param jobType
     * @param cronExpress cron 表达式
     */
    public void scheduleJob(Scheduler scheduler, EnumCheckJobType jobType, String cronExpress) {
        try {
            scheduleJob(scheduler, jobType, CronScheduleBuilder.cronSchedule(cronExpress));
        } catch (SchedulerException e) {

        }
    }


    /**
     * 注册调度任务
     *
     * @param scheduler
     * @param jobType
     * @param interval  间隔时间
     */
    public void scheduleJob(Scheduler scheduler, EnumCheckJobType jobType, int interval) {
        try {
            scheduleJob(scheduler, jobType, SimpleScheduleBuilder.simpleSchedule()
                    .withIntervalInSeconds(interval)
                    .repeatForever()
                    .withMisfireHandlingInstructionNowWithExistingCount());//misfire策略
        } catch (SchedulerException e) {

        }
    }

    /**
     * 注册调度任务
     *
     * @param scheduler
     * @param jobType
     * @param builder
     */
    public <T extends Trigger> void scheduleJob(Scheduler scheduler, EnumCheckJobType jobType, ScheduleBuilder<T> builder) throws SchedulerException {

        SchedulerTask task = newTask(jobType);
        if (task == null) {
            throw new SchedulerException();
        }

        JobDetail job = JobBuilder.newJob(MyJob.class)
                .withIdentity(getJobName(jobType), getJobGroupName(jobType))
                .build();

        job.getJobDataMap().put("task", task);

        // 第二天的零点开始执行
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(getJobTriggerName(jobType), getJobGroupName(jobType))
                .forJob(job.getKey())
                .withSchedule(builder)
                .startAt(DateBuilder.tomorrowAt(0, 0, 0))
                .build();

        scheduler.scheduleJob(job, trigger);

    }


    private String getJobName(EnumCheckJobType checkType) {
        return checkType.name();
    }



    private String getJobGroupName(EnumCheckJobType checkType) {
        return "group-" + checkType.name();
    }


    private String getJobTriggerName(EnumCheckJobType jobType) {
        return jobType.name();
    }


    private SchedulerTask newTask(EnumCheckJobType jobType) {
        switch (jobType) {
            case ONE:
                return applicationContext.getBean
                        (OneScheduler.class);
            case TWO:
                return applicationContext.getBean
                        (TwoScheduler.class);
            default:
                return null;
        }
    }
}

HelloQuartz,主函数

public class HelloQuartz {
    public static void main(String[] args) throws SchedulerException {
        MyScheduler myScheduler = new MyScheduler();
        try {
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
            myScheduler.scheduleJob(scheduler, EnumCheckJobType.ONE, "0 0 0 * * ?");//每天的凌晨0点执行
            myScheduler.scheduleJob(scheduler, EnumCheckJobType.TWO, 60);//间隔60S执行一次
        } catch (SchedulerException e) {

        }
    }
}

Quartz的3个基本要素

  • Scheduler:调度器。所有的调度都是由它控制。
  • Trigger: 触发器。决定什么时候来执行任务。
  • JobDetail & Job: JobDetail 定义的是任务数据,而真正的执行逻辑是在Job中。使用JobDetail + Job而不是Job,这是因为任务是有可能并发执行,如果Scheduler直接使用Job,就会存在对同一个Job实例并发访问的问题。而JobDetail & Job 方式,sheduler每次执行,都会根据JobDetail创建一个新的Job实例,这样就可以规避并发访问的问题。

name和group

JobDetail和Trigger都有name和group。

name是它们在这个sheduler里面的唯一标识。如果我们要更新一个JobDetail定义,只需要设置一个name相同的JobDetail实例即可。

group是一个组织单元,sheduler会提供一些对整组操作的API,比如 scheduler.resumeJobs()。

misfire(错失触发)策略

当系统由于某种原因(未启动或是没有可用线程)在预定时刻没有启动任务,之后当系统可以调度该任务时(系统启动或是取得了可用线程),会首先检查当前时刻与预定时刻的差值,如果小于等于misfireThreshold值(该参数缺省为60秒),则不认为发生Misfire,并立刻启动该任务,一切正常进行。如果大于misfireThreshold值,则认为发生了misfire,此时的行为由trigger的Misfire Instructions来决定。而不同类型的trigger的缺省Misfire Instructions是不同的。

对于典型的SimpleTrigger: 

缺省Misfire策略为Trigger.MISFIRE_INSTRUCTION_SMART_POLICY ,其他策略如下:

SimpleScheduleBuilder ssb = SimpleScheduleBuilder.simpleSchedule();
ssb.withMisfireHandlingInstructionFireNow();//1
ssb.withMisfireHandlingInstructionIgnoreMisfires();//2
ssb.withMisfireHandlingInstructionNextWithExistingCount();//3
ssb.withMisfireHandlingInstructionNextWithRemainingCount();//4
ssb.withMisfireHandlingInstructionNowWithExistingCount();//5
ssb.withMisfireHandlingInstructionNowWithRemainingCount();//6

//1
withMisfireHandlingInstructionFireNow  ---> SimpleTrigger.MISFIRE_INSTRUCTION_FIRE_NOW (misfireInstruction == 1)
——以当前时间为触发频率立即触发执行
——执行至FinalTIme的剩余周期次数
——以调度或恢复调度的时刻为基准的周期频率,FinalTime根据剩余次数和当前时间计算得到
——调整后的FinalTime会略大于根据starttime计算的到的FinalTime值

//2
withMisfireHandlingInstructionIgnoreMisfires ---> Trigger.MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY(misfireInstruction == -1)
—以错过的第一个频率时间立刻开始执行
——重做错过的所有频率周期
——当下一次触发频率发生时间大于当前时间以后,按照Interval的依次执行剩下的频率
——共执行RepeatCount+1次

//3
withMisfireHandlingInstructionNextWithExistingCount ---> SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT(misfireInstruction == 5)
——不触发立即执行
——等待下次触发频率周期时刻,执行至FinalTime的剩余周期次数
——以startTime为基准计算周期频率,并得到FinalTime
——即使中间出现pause,resume以后保持FinalTime时间不变

//4
withMisfireHandlingInstructionNextWithRemainingCount ---> SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT(misfireInstruction == 4)
——不触发立即执行
——等待下次触发频率周期时刻,执行至FinalTime的剩余周期次数
——以startTime为基准计算周期频率,并得到FinalTime
——即使中间出现pause,resume以后保持FinalTime时间不变

//5
withMisfireHandlingInstructionNowWithExistingCount ---> SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT(misfireInstruction == 2)
——以当前时间为触发频率立即触发执行
——执行至FinalTIme的剩余周期次数
——以调度或恢复调度的时刻为基准的周期频率,FinalTime根据剩余次数和当前时间计算得到
——调整后的FinalTime会略大于根据starttime计算的到的FinalTime值

//6
withMisfireHandlingInstructionNowWithRemainingCount ---> SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_REMAINING_REPEAT_COUNT(misfireInstruction == 3)
——以当前时间为触发频率立即触发执行
——执行至FinalTIme的剩余周期次数
——以调度或恢复调度的时刻为基准的周期频率,FinalTime根据剩余次数和当前时间计算得到
——调整后的FinalTime会略大于根据starttime计算的到的FinalTime值

基于在创建SimpleTrigger时选择的MISFIRE_INSTRUCTION_XXX更新SimpleTrigger的状态。 如果失火指令设置为MISFIRE_INSTRUCTION_SMART_POLICY,则将使用以下方案:

  • 如果重复计数为0,则指令将解释为MISFIRE_INSTRUCTION_FIRE_NOW。
  • 如果重复计数为REPEAT_INDEFINITELY(repeatForever),则指令将解释为MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT。 警告:如果触发器具有非空的结束时间,则使用MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT可能会导致触发器在失火时间范围内到达结束时,不会再次触发。
  • 如果重复计数大于0,则指令将解释为MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT。

对于典型的CronTrigger: 

缺省Misfire策略为Trigger.MISFIRE_INSTRUCTION_SMART_POLICY ,其他策略如下:

CronScheduleBuilder csb = CronScheduleBuilder.cronSchedule("0/5 * * * * ?");
csb.withMisfireHandlingInstructionDoNothing();
csb.withMisfireHandlingInstructionFireAndProceed();
csb.withMisfireHandlingInstructionIgnoreMisfires();

withMisfireHandlingInstructionDoNothing ---> CronTrigger.MISFIRE_INSTRUCTION_DO_NOTHING(misfireInstruction = 2)
——不触发立即执行
——等待下次Cron触发频率到达时刻开始按照Cron频率依次执行

withMisfireHandlingInstructionFireAndProceed ---> CronTrigger.MISFIRE_INSTRUCTION_FIRE_ONCE_NOW(misfireInstruction = 1)
——以当前时间为触发频率立刻触发一次执行
——然后按照Cron频率依次执行

withMisfireHandlingInstructionIgnoreMisfires ---> Trigger.MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY(misfireInstruction = -1)
——以错过的第一个频率时间立刻开始执行
——重做错过的所有频率周期后
——当下一次触发频率发生时间大于当前时间后,再按照正常的Cron频率依次执行

根据创建CronTrigger时选择的MISFIRE_INSTRUCTION_XXX更新CronTrigger的状态。 如果失火指令设置为MISFIRE_INSTRUCTION_SMART_POLICY,则将使用以下方案:

  • 指令将解释为MISFIRE_INSTRUCTION_FIRE_ONCE_NOW

参考

这里有一篇博客总结的非常好,记录并分享下

http://www.cnblogs.com/drift-ice/p/3817269.html

                                     

 

 

 

以上是关于Quartz总结的主要内容,如果未能解决你的问题,请参考以下文章

quartz 定时任务的总结 trigger SimpleTrigger CronTrigger

Quartz总结

Quartz.NET总结Quartz 远程调度

Quartz学习总结

Quartz学习总结

Quartz总结:Quartz集成Spring的2个方法