Quartz Trigger详细介绍

2019/10/24 14:35
阅读数 113

Trigger的公共属性

triggerKey:表示Trigger身份的属性

jobKey:Trigger触发时被执行的Job的身份

startTime:Trigger第一次触发的时间

endTime:Trigger失效的时间点

 

Trigger的其它属性

优先级(priority):如果Trigger很多,或者Quartz线程池的工作线程太少,Quartz可能没有足够的资源同事触发所有的Trigger,这种情况下,如果希望某些Trigger优先被触发,就需要给它设置优先级,Trigger默认的优先级为5,优先级priority属性的值可以是任意整数,正数、负数都可以。(只有同时触发的Trigger之间才会比较优先级)

 

错失触发(misfire):如果Scheduler关闭了,或者Quartz线程池中没有可用的线程来执行Job,此时持久性的Trigger就会错过其触发时间,即错失触发。不同类型的Trigger,有不同的misfire机制,它们都默认使用“智能机制(smart policy)”,即根据Trigger的类型和配置动态调整行为,当Scheduler启动的时候,查询所有错过触发机制的持久性Trigger,然后根据它们各自的misfire机制更新Trigger的信息。

 

日历(Calendar)示例

Quartz的Calendar对象(不是java.util.Calendar对象)可以在定义和存储trigger的时候与trigger进行关联。Calendar用于从trigger的调度计划中排除时间段。

 

各种常用Trigger

SimpleTrigger

指定从某一个时间开始,以一定时间间隔(单位:毫秒)执行的任务。

它的属性有:

repeatInterval:重复间隔

repeatCount:重复次数,实际执行次数是repeatCount+1(因为在startTime的时候一定会执行一次)

SimpleTrigger trigger = newTrigger()
       .withIdentity("trigger1", "group1")
       .startAt(futureDate(5, DateBuilder.IntervalUnit.SECOND))
       .withSchedule(simpleSchedule().withIntervalInSeconds(10).withRepeatCount(10))
       .endAt(dateOf(18, 0, 0))
       .forJob(job)
       .build();

注意:endTime属性的值会覆盖repeatCount的属性值。

TriggerBuilder(以及Quartz的其他Builder)会为那些没有被显示设置的属性选择合理的默认值,例如:如果没有调用withIdentity(..)方法,TriggerBuilder会为trigger生成一个随机的名称;如果没有调用startAt(..)方法,则默认使用当前时间,即trigger立即生效。

CalendarIntervalTrigger

类似于SimpleTrigger,指定从某一个时间开始,以一定的时间间隔执行的任务。 但是不同的是SimpleTrigger指定的时间间隔为毫秒,没办法指定每隔一个月执行一次(每月的时间间隔不是固定值),而CalendarIntervalTrigger支持的间隔单位有秒,分钟,小时,天,月,年,星期。

相较于SimpleTrigger有两个优势:

1、更方便,比如每隔1小时执行,你不用自己去计算1小时等于多少毫秒

2、支持不是固定长度的间隔,比如间隔为月和年。但劣势是精度只能到秒

它的属性有:

interval 执行间隔

intervalUnit 执行间隔的单位(秒,分钟,小时,天,月,年,星期)

CalendarIntervalTrigger trigger = newTrigger()
       .withIdentity("trigger1", "group1")
       .startNow()
       .withSchedule(calendarIntervalSchedule().withInterval(10, DateBuilder.IntervalUnit.SECOND))
       //.withSchedule(calendarIntervalSchedule().withIntervalInDays(1))
       .endAt(dateOf(18, 0, 0))
       .forJob(job)
       .build();

DailyTimeIntervalTrigger

指定每天的某个时间段内,以一定的时间间隔执行任务。并且它可以支持指定星期。

它的属性有:

startTimeOfDay 每天开始时间

endTimeOfDay 每天结束时间

daysOfWeek 需要执行的星期

interval 执行间隔

intervalUnit 执行间隔的单位(秒,分钟,小时,天,月,年,星期)

repeatCount 重复次数

DailyTimeIntervalTrigger trigger = newTrigger()
       .withIdentity("trigger1", "group1")
       .startNow()
       .withSchedule(dailyTimeIntervalSchedule()
               .onDaysOfTheWeek(MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY) //周一至周五执行
               .withInterval(10, DateBuilder.IntervalUnit.SECOND))
       .forJob(job)
       .build();

CronTrigger

适合于更复杂的任务,它支持类型于Linux Cron的语法(并且更强大)。

CronTrigger trigger = newTrigger()
       .withIdentity("trigger1", "group1")
       .startNow()
       .withSchedule(cronSchedule("*/1 * * * * ?"))
       .forJob(job)
       .build();

注意:如果一些调度要求太复杂,无法用单一触发表示,那么就应该创建多个Trigger,Job和Trigger是松耦合的,一个Job可以定义多个Trigger。

public class HelloJob implements Job {
   @Override
   public void execute(JobExecutionContext context) throws JobExecutionException {
       try {
           JobDetail job = context.getJobDetail();
           String name = job.getJobDataMap().getString("name");
           Trigger trigger = context.getTrigger();
           System.out.println("Run By Trigger: " + trigger.getKey() + ", hello " + name + " at " + new Date());
       } catch (Exception e) {
           e.printStackTrace();
       }
   }
}
Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

scheduler.start();

JobDetail job = newJob(HelloJob.class)
       .withIdentity("job1", "group1")
       .usingJobData("name", "quartz").build();

CronTrigger trigger1 = newTrigger()
       .withIdentity("trigger1", "group1")
       .startNow()
       .withSchedule(cronSchedule("*/5 * 9-12 * * ?"))
       .forJob(job)
       .build();

CronTrigger trigger2 = newTrigger()
       .withIdentity("trigger2", "group1")
       .startNow()
       .withSchedule(cronSchedule("0 */1 14-18 * * ?"))
       .forJob(job)
       .build();

Set<Trigger> triggerSet = new HashSet<>();
triggerSet.add(trigger1);
triggerSet.add(trigger2);
scheduler.scheduleJob(job, triggerSet, true);

try {
   Thread.sleep(1000L * 60L * 10L);
} catch (InterruptedException e) {
   e.printStackTrace();
}

scheduler.shutdown();

 

Misfire策略

MISFIRE_INSTRUCTION_SMART_POLICY:所有Trigger的MisFire默认策略,即:把处理逻辑交给从Smart的Quartz去决定。

基本策略:

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

> 如果是无限次的调度(repeatCount是无限的),使用MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT

> 否则,使用MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT

MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY:忽略MisFire策略,在资源适合的时候,重新出发所有MisFire任务,不影响现有的调度

 

SimpleTrigger Misfire策略

MISFIRE_INSTRUCTION_FIRE_NOW:忽略已经MisFire的任务,并且立即执行调度,通常只适用于只执行一次任务的场景

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

MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_REMAINING_REPEAT_COUNT:与上一个策略类似,区别在于该策略会忽略MisFire的任务

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

MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT:与上一个策略类似,区别在于该策略会忽略MisFire的任务

 

CronTrigger Misfire策略

MISFIRE_INSTRUCTION_DO_NOTHING:什么都不做,继续等下一次调度时间再触发

MISFIRE_INSTRUCTION_FIRE_NOW:忽略已经MisFire的任务,并且立即执行调度,通常只适用于只执行一次任务的场景

 

Listeners

Listener用于在调度过程中监听事件操作,不过,大多数情况下,用户并不会使用Listener。JobListener、TriggerListener、SchedulerListener的用法类似,无非就是addXXXListener()、removeXXXListener()的操作,下面以JobListener为例介绍:

创建一个自定义的JobListener:

public class MyJobListener implements JobListener {
   @Override
   public String getName() {
       System.out.println("getName()");
       return "getName()";
   }


   @Override
   public void jobToBeExecuted(JobExecutionContext jobExecutionContext) {
       System.out.println("jobToBeExecuted()");
   }

   @Override
   public void jobExecutionVetoed(JobExecutionContext jobExecutionContext) {
       System.out.println("jobExecutionVetoed()");
   }

   @Override
   public void jobWasExecuted(JobExecutionContext jobExecutionContext, JobExecutionException e) {
       System.out.println("jobWasExecuted()");
   }
}

 

使用JobListener:

public class JobListenerDemo {

   public static void main(String[] args) {
       try {
           Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

           MyJobListener myJobListener = new MyJobListener();

           //添加监听
           scheduler.getListenerManager().addJobListener(myJobListener, KeyMatcher.keyEquals(jobKey("job1", "group1")));
           //scheduler.getListenerManager().addJobListener(new MyJobListener(), GroupMatcher.groupEquals("group1"));

           //移除监听
           //scheduler.getListenerManager().removeJobListener(myJobListener.getName());

           scheduler.start();

           JobDetail job = newJob(HelloJob.class).withIdentity("job1", "group1")
                   .usingJobData("name", "quartz").build();

           Trigger trigger = newTrigger().withIdentity("trigger1", "group1").startNow()
                   .withSchedule(simpleSchedule().withIntervalInSeconds(1).repeatForever()).build();

           scheduler.scheduleJob(job, trigger);

           try {
               Thread.sleep(1000L * 60L * 10L);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }

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

 

参考资料

1、Quartz官方文档:https://www.w3cschool.cn/quartz_doc/

2、Quartz官网:http://www.quartz-scheduler.org/

3、Quartz使用总结:https://www.cnblogs.com/drift-ice/p/3817269.html

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部