ITPub博客
首页 博客 专栏 学院 社区 IT新媒体评选
发博

首页 > 应用开发 > Java > quartz详解5：官网example分析

quartz详解5：官网example分析

原创 Java 作者：Tim_java 时间：2015-08-17 14:37:26 0 删除 编辑
    quartz官方提供了15个example，方便开发者理解quartz的用法。现在结合源码对实例的使用进行分析。
参见：http://www.quartz-scheduler.org/documentation/quartz-2.2.x/examples/

example1:First Quartz Program
1、实例内容包括：
  • 启动Quartz Scheduler
  • 等待下一个整点后执行任务
  • 退出Quartz Scheduler
2、代码：
  • SimpleExample：主体程序
  • HelloJob：一个简单的任务，打印Hello World
HelloJob：

点击(此处)折叠或打开

  1. public class HelloJob implements Job {

  3.     private static Logger _log = LoggerFactory.getLogger(HelloJob.class);

  5.   
  6.     public HelloJob() {
  7.     }

  9.    
  10.     public void execute(JobExecutionContext context)
  11.         throws JobExecutionException {

  13.         // Say Hello to the World and display the date/time
  14.         _log.info("Hello World! - " + new Date());
  15.     }

  17. }
查上面代码，HelloJob只是一个很简单的定时任务，实现了Job接口，同时实现了execute方法，然后方法内打印了当前时间。

SimpleExample：

点击(此处)折叠或打开


  2.  
  3. package org.quartz.examples.example1;

  5. import static org.quartz.DateBuilder.evenMinuteDate;
  6. import static org.quartz.JobBuilder.newJob;
  7. import static org.quartz.TriggerBuilder.newTrigger;

  9. import org.quartz.JobDetail;
  10. import org.quartz.Scheduler;
  11. import org.quartz.SchedulerFactory;
  12. import org.quartz.Trigger;
  13. import org.quartz.impl.StdSchedulerFactory;
  14. import org.slf4j.Logger;
  15. import org.slf4j.LoggerFactory;

  17. import java.util.Date;

  19. /**
  20.  * This Example will demonstrate how to start and shutdown the Quartz scheduler and how to schedule a job to run in
  21.  * Quartz.
  22.  *
  23.  * @author Bill Kratzer
  24.  */
  25. public class SimpleExample {

  27.   public void run() throws Exception {
  28.     Logger log = LoggerFactory.getLogger(SimpleExample.class);

  30.     log.info("------- Initializing ----------------------");

  32.     // First we must get a reference to a scheduler
  33.     SchedulerFactory sf = new StdSchedulerFactory();
  34.     Scheduler sched = sf.getScheduler();

  36.     log.info("------- Initialization Complete -----------");

  38.     // computer a time that is on the next round minute
  39.     Date runTime = evenMinuteDate(new Date());

  41.     log.info("------- Scheduling Job -------------------");

  43.     // define the job and tie it to our HelloJob class
  44.     JobDetail job = newJob(HelloJob.class).withIdentity("job1", "group1").build();

  46.     // Trigger the job to run on the next round minute
  47.     Trigger trigger = newTrigger().withIdentity("trigger1", "group1").startAt(runTime).build();

  49.     // Tell quartz to schedule the job using our trigger
  50.     sched.scheduleJob(job, trigger);
  51.     log.info(job.getKey() + " will run at: " + runTime);

  53.     // Start up the scheduler (nothing can actually run until the
  54.     // scheduler has been started)
  55.     sched.start();

  57.     log.info("------- Started Scheduler -----------------");

  59.     // wait long enough so that the scheduler as an opportunity to
  60.     // run the job!
  61.     log.info("------- Waiting 65 seconds... -------------");
  62.     try {
  63.       // wait 65 seconds to show job
  64.       Thread.sleep(65L * 1000L);
  65.       // executing...
  66.     } catch (Exception e) {
  67.       //
  68.     }

  70.     // shut down the scheduler
  71.     log.info("------- Shutting Down ---------------------");
  72.     sched.shutdown(true);
  73.     log.info("------- Shutdown Complete -----------------");
  74.   }

  76.   public static void main(String[] args) throws Exception {

  78.     SimpleExample example = new SimpleExample();
  79.     example.run();

  81.   }

  83. }
1）首先创建一个Scheduler，参照quartz详解2，此时还没有打开启动quartz的主线程QuartzSchedulerThread的开关。
SchedulerFactory sf = new StdSchedulerFactory();
Scheduler sched = sf.getScheduler();
2）定义JobDetail和Trigger，并添加一个定时任务，在下一个整点执行：
Date runTime = evenMinuteDate(new Date());
// define the job and tie it to our HelloJob class
Date runTime = evenMinuteDate(new Date());JobDetail job = newJob(HelloJob.class).withIdentity("job1", "group1").build();
Trigger trigger = newTrigger().withIdentity("trigger1", "group1").startAt(runTime).build();
sched.scheduleJob(job, trigger);
3）打开开关启动scheduler
// define the job and tie it to our HelloJob class
sched.start();
4）等待65秒后停止Scheduler
sched.shutdown(true);

Example 2 - Simple Triggers
1、实例内容也是Simple Trigger的使用，不一样的是批量的使用。
2、代码：
  • SimpleTriggerExample：主体程序
  • SimpleJob：一个简单的任务，打印当前时间
SimpleJob：

点击(此处)折叠或打开

  1. public void execute(JobExecutionContext context)
  2.         throws JobExecutionException {

  4.         // This job simply prints out its job name and the
  5.         // date and time that it is running
  6.         JobKey jobKey = context.getJobDetail().getKey();
  7.         _log.info("SimpleJob says: " + jobKey + " executing at " + new Date());
  8.     }
SimpleTriggerExample：

点击(此处)折叠或打开

  1. /*
  2.  * All content copyright Terracotta, Inc., unless otherwise indicated. All rights reserved.
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  5.  * use this file except in compliance with the License. You may obtain a copy
  6.  * of the License at
  7.  *
  8.  * http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  12.  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  13.  * License for the specific language governing permissions and limitations
  14.  * under the License.
  15.  *
  16.  */
  17.  
  18. package org.quartz.examples.example2;

  20. import static org.quartz.DateBuilder.futureDate;
  21. import static org.quartz.JobBuilder.newJob;
  22. import static org.quartz.JobKey.jobKey;
  23. import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
  24. import static org.quartz.TriggerBuilder.newTrigger;

  26. import org.quartz.DateBuilder;
  27. import org.quartz.DateBuilder.IntervalUnit;
  28. import org.quartz.JobDetail;
  29. import org.quartz.Scheduler;
  30. import org.quartz.SchedulerFactory;
  31. import org.quartz.SchedulerMetaData;
  32. import org.quartz.SimpleTrigger;
  33. import org.quartz.impl.StdSchedulerFactory;
  34. import org.slf4j.Logger;
  35. import org.slf4j.LoggerFactory;

  37. import java.util.Date;

  39. /**
  40.  * This Example will demonstrate all of the basics of scheduling capabilities of Quartz using Simple Triggers.
  41.  *
  42.  * @author Bill Kratzer
  43.  */
  44. public class SimpleTriggerExample {

  46.   public void run() throws Exception {
  47.     Logger log = LoggerFactory.getLogger(SimpleTriggerExample.class);

  49.     log.info("------- Initializing -------------------");

  51.     // First we must get a reference to a scheduler
  52.     SchedulerFactory sf = new StdSchedulerFactory();
  53.     Scheduler sched = sf.getScheduler();

  55.     log.info("------- Initialization Complete --------");

  57.     log.info("------- Scheduling Jobs ----------------");

  59.     // jobs can be scheduled before sched.start() has been called

  61.     // get a "nice round" time a few seconds in the future...
  62.     Date startTime = DateBuilder.nextGivenSecondDate(null, 15);

  64.     // job1 will only fire once at date/time "ts"
  65.     JobDetail job = newJob(SimpleJob.class).withIdentity("job1", "group1").build();

  67.     SimpleTrigger trigger = (SimpleTrigger) newTrigger().withIdentity("trigger1", "group1").startAt(startTime).build();

  69.     // schedule it to run!
  70.     Date ft = sched.scheduleJob(job, trigger);
  71.     log.info(job.getKey() + " will run at: " + ft + " and repeat: " + trigger.getRepeatCount() + " times, every "
  72.              + trigger.getRepeatInterval() / 1000 + " seconds");

  74.     // job2 will only fire once at date/time "ts"
  75.     job = newJob(SimpleJob.class).withIdentity("job2", "group1").build();

  77.     trigger = (SimpleTrigger) newTrigger().withIdentity("trigger2", "group1").startAt(startTime).build();

  79.     ft = sched.scheduleJob(job, trigger);
  80.     log.info(job.getKey() + " will run at: " + ft + " and repeat: " + trigger.getRepeatCount() + " times, every "
  81.              + trigger.getRepeatInterval() / 1000 + " seconds");

  83.     // job3 will run 11 times (run once and repeat 10 more times)
  84.     // job3 will repeat every 10 seconds
  85.     job = newJob(SimpleJob.class).withIdentity("job3", "group1").build();

  87.     trigger = newTrigger().withIdentity("trigger3", "group1").startAt(startTime)
  88.         .withSchedule(simpleSchedule().withIntervalInSeconds(10).withRepeatCount(10)).build();

  90.     ft = sched.scheduleJob(job, trigger);
  91.     log.info(job.getKey() + " will run at: " + ft + " and repeat: " + trigger.getRepeatCount() + " times, every "
  92.              + trigger.getRepeatInterval() / 1000 + " seconds");

  94.     // the same job (job3) will be scheduled by a another trigger
  95.     // this time will only repeat twice at a 70 second interval

  97.     trigger = newTrigger().withIdentity("trigger3", "group2").startAt(startTime)
  98.         .withSchedule(simpleSchedule().withIntervalInSeconds(10).withRepeatCount(2)).forJob(job).build();

  100.     ft = sched.scheduleJob(trigger);
  101.     log.info(job.getKey() + " will [also] run at: " + ft + " and repeat: " + trigger.getRepeatCount()
  102.              + " times, every " + trigger.getRepeatInterval() / 1000 + " seconds");

  104.     // job4 will run 6 times (run once and repeat 5 more times)
  105.     // job4 will repeat every 10 seconds
  106.     job = newJob(SimpleJob.class).withIdentity("job4", "group1").build();

  108.     trigger = newTrigger().withIdentity("trigger4", "group1").startAt(startTime)
  109.         .withSchedule(simpleSchedule().withIntervalInSeconds(10).withRepeatCount(5)).build();

  111.     ft = sched.scheduleJob(job, trigger);
  112.     log.info(job.getKey() + " will run at: " + ft + " and repeat: " + trigger.getRepeatCount() + " times, every "
  113.              + trigger.getRepeatInterval() / 1000 + " seconds");

  115.     // job5 will run once, five minutes in the future
  116.     job = newJob(SimpleJob.class).withIdentity("job5", "group1").build();

  118.     trigger = (SimpleTrigger) newTrigger().withIdentity("trigger5", "group1")
  119.         .startAt(futureDate(5, IntervalUnit.MINUTE)).build();

  121.     ft = sched.scheduleJob(job, trigger);
  122.     log.info(job.getKey() + " will run at: " + ft + " and repeat: " + trigger.getRepeatCount() + " times, every "
  123.              + trigger.getRepeatInterval() / 1000 + " seconds");

  125.     // job6 will run indefinitely, every 40 seconds
  126.     job = newJob(SimpleJob.class).withIdentity("job6", "group1").build();

  128.     trigger = newTrigger().withIdentity("trigger6", "group1").startAt(startTime)
  129.         .withSchedule(simpleSchedule().withIntervalInSeconds(40).repeatForever()).build();

  131.     ft = sched.scheduleJob(job, trigger);
  132.     log.info(job.getKey() + " will run at: " + ft + " and repeat: " + trigger.getRepeatCount() + " times, every "
  133.              + trigger.getRepeatInterval() / 1000 + " seconds");

  135.     log.info("------- Starting Scheduler ----------------");

  137.     // All of the jobs have been added to the scheduler, but none of the jobs
  138.     // will run until the scheduler has been started
  139.     sched.start();

  141.     log.info("------- Started Scheduler -----------------");

  143.     // jobs can also be scheduled after start() has been called...
  144.     // job7 will repeat 20 times, repeat every five minutes
  145.     job = newJob(SimpleJob.class).withIdentity("job7", "group1").build();

  147.     trigger = newTrigger().withIdentity("trigger7", "group1").startAt(startTime)
  148.         .withSchedule(simpleSchedule().withIntervalInMinutes(5).withRepeatCount(20)).build();

  150.     ft = sched.scheduleJob(job, trigger);
  151.     log.info(job.getKey() + " will run at: " + ft + " and repeat: " + trigger.getRepeatCount() + " times, every "
  152.              + trigger.getRepeatInterval() / 1000 + " seconds");

  154.     // jobs can be fired directly... (rather than waiting for a trigger)
  155.     job = newJob(SimpleJob.class).withIdentity("job8", "group1").storeDurably().build();

  157.     sched.addJob(job, true);

  159.     log.info("'Manually' triggering job8...");
  160.     sched.triggerJob(jobKey("job8", "group1"));

  162.     log.info("------- Waiting 30 seconds... --------------");

  164.     try {
  165.       // wait 33 seconds to show jobs
  166.       Thread.sleep(30L * 1000L);
  167.       // executing...
  168.     } catch (Exception e) {
  169.       //
  170.     }

  172.     // jobs can be re-scheduled...
  173.     // job 7 will run immediately and repeat 10 times for every second
  174.     log.info("------- Rescheduling... --------------------");
  175.     trigger = newTrigger().withIdentity("trigger7", "group1").startAt(startTime)
  176.         .withSchedule(simpleSchedule().withIntervalInMinutes(5).withRepeatCount(20)).build();

  178.     ft = sched.rescheduleJob(trigger.getKey(), trigger);
  179.     log.info("job7 rescheduled to run at: " + ft);

  181.     log.info("------- Waiting five minutes... ------------");
  182.     try {
  183.       // wait five minutes to show jobs
  184.       Thread.sleep(300L * 1000L);
  185.       // executing...
  186.     } catch (Exception e) {
  187.       //
  188.     }

  190.     log.info("------- Shutting Down ---------------------");

  192.     sched.shutdown(true);

  194.     log.info("------- Shutdown Complete -----------------");

  196.     // display some stats about the schedule that just ran
  197.     SchedulerMetaData metaData = sched.getMetaData();
  198.     log.info("Executed " + metaData.getNumberOfJobsExecuted() + " jobs.");

  200.   }

  202.   public static void main(String[] args) throws Exception {

  204.     SimpleTriggerExample example = new SimpleTriggerExample();
  205.     example.run();

  207.   }

  209. }
job3每10秒执行1次，重复10次，一共执行11次。

点击(此处)折叠或打开

  1. // job3 will run 11 times (run once and repeat 10 more times)
  2.     // job3 will repeat every 10 seconds
  3.     job = newJob(SimpleJob.class).withIdentity("job3", "group1").build();

  5.     trigger = newTrigger().withIdentity("trigger3", "group1").startAt(startTime)
  6.         .withSchedule(simpleSchedule().withIntervalInSeconds(10).withRepeatCount(10)).build();
同样是job3，新增一个trigger来触发它。
因为在版本2.2.1中，是可以支持多个trigger来对应触发同一个JOB的。

点击(此处)折叠或打开

  1. trigger = newTrigger().withIdentity("trigger3", "group2").startAt(startTime)
  2.         .withSchedule(simpleSchedule().withIntervalInSeconds(10).withRepeatCount(2)).forJob(job).build();
job5也可以设置5分钟后执行：

点击(此处)折叠或打开

  1. // job5 will run once, five minutes in the future
  2.     job = newJob(SimpleJob.class).withIdentity("job5", "group1").build();

  4.     trigger = (SimpleTrigger) newTrigger().withIdentity("trigger5", "group1")
  5.         .startAt(futureDate(5, IntervalUnit.MINUTE)).build();
job6设置每40秒执行，一直执行：

点击(此处)折叠或打开

  1. job = newJob(SimpleJob.class).withIdentity("job6", "group1").build();

  3.     trigger = newTrigger().withIdentity("trigger6", "group1").startAt(startTime)
  4.         .withSchedule(simpleSchedule().withIntervalInSeconds(40).repeatForever()).build();
job7是可以在scheduler启动后再创建，加入到scheduler中。
job8表示，不需要创建trigger，可以直接触发任务。




example3：Cron Trigger
job1是每20秒执行一次：

点击(此处)折叠或打开

  1. JobDetail job = newJob(SimpleJob.class)
  2.     .withIdentity("job1", "group1")
  3.     .build();

  5. CronTrigger trigger = newTrigger()
  6.     .withIdentity("trigger1", "group1")
  7.     .withSchedule(cronSchedule("0/20 * * * * ?"))
  8.     .build();

  10. sched.scheduleJob(job, trigger);
Jo2是每2分钟执行一次，在15秒这个点执行。如1分15秒，3分15秒，5分15秒。

点击(此处)折叠或打开

  1. JobDetail job = newJob(SimpleJob.class)
  2.     .withIdentity("job1", "group1")
  3.     .build();

  5. CronTrigger trigger = newTrigger()
  6.     .withIdentity("trigger1", "group1")
  7.     .withSchedule(cronSchedule("0/20 * * * * ?"))
  8.     .build();

  10. sched.scheduleJob(job, trigger);
JOB3是每2分种的整点执行一次，在上午8点到下午17点之间。

点击(此处)折叠或打开

  1. // job 3 will run every other minute but only between 8am and 5pm
  2.     job = newJob(SimpleJob.class).withIdentity("job3", "group1").build();

  4.     trigger = newTrigger().withIdentity("trigger3", "group1").withSchedule(cronSchedule("0 0/2 8-17 * * ?")).build();

  6.     ft = sched.scheduleJob(job, trigger);
  7.     log.info(job.getKey() + " has been scheduled to run at: " + ft + " and repeat based on expression: "
  8.              + trigger.getCronExpression());
JOB5在每个月1号和15号的上午10点执行：

点击(此处)折叠或打开

  1. // job 5 will run at 10am on the 1st and 15th days of the month
  2.     job = newJob(SimpleJob.class).withIdentity("job5", "group1").build();

  4.     trigger = newTrigger().withIdentity("trigger5", "group1").withSchedule(cronSchedule("0 0 10am 1,15 * ?")).build();

  6.     ft = sched.scheduleJob(job, trigger);
  7.     log.info(job.getKey() + " has been scheduled to run at: " + ft + " and repeat based on expression: "
  8.              + trigger.getCronExpression());
JOB6在每周一到周五执行，每30秒执行一次。
"0,30 * * ? * MON-FRI"
JOB7在每个周六和周日执行，每30秒执行一次。
"0,30 * * ? * MON-FRI"

Example 4 - Job Parameters and Job State
可以为job设置参数和状态。
@DisallowConcurrentExecution 注解的含义相关于1.8.6版本中的stateful job，就是说同一个trigger在上一次没有执行完成时，下一个不能执行。
比如trigger是30s执行一次，一个任务执行了37秒，那么第二个任务需要等37s后，前一个任务执行后了才可以执行。
那么第二个任务是在37s执行，还是在下一个周期60s的时候执行呢？
@PersistJobDataAfterExecution　代表执行完后的job的数据在jobMap中不共享，一般用于有状态的job...

点击(此处)折叠或打开

  1. @PersistJobDataAfterExecution
  2. @DisallowConcurrentExecution
  3. public class ColorJob implements Job {

看一下例子：

点击(此处)折叠或打开

  1. public class JobStateExample {

  3.   public void run() throws Exception {
  4.     Logger log = LoggerFactory.getLogger(JobStateExample.class);

  6.     log.info("------- Initializing -------------------");

  8.     // First we must get a reference to a scheduler
  9.     SchedulerFactory sf = new StdSchedulerFactory();
  10.     Scheduler sched = sf.getScheduler();

  12.     log.info("------- Initialization Complete --------");

  14.     log.info("------- Scheduling Jobs ----------------");

  16.     // get a "nice round" time a few seconds in the future....
  17.     Date startTime = nextGivenSecondDate(null, 10);

  19.     // job1 will only run 5 times (at start time, plus 4 repeats), every 10 seconds
  20.     JobDetail job1 = newJob(ColorJob.class).withIdentity("job1", "group1").build();

  22.     SimpleTrigger trigger1 = newTrigger().withIdentity("trigger1", "group1").startAt(startTime)
  23.         .withSchedule(simpleSchedule().withIntervalInSeconds(10).withRepeatCount(4)).build();

  25.     // pass initialization parameters into the job
  26.     job1.getJobDataMap().put(ColorJob.FAVORITE_COLOR, "Green");
  27.     job1.getJobDataMap().put(ColorJob.EXECUTION_COUNT, 1);

  29.     // schedule the job to run
  30.     Date scheduleTime1 = sched.scheduleJob(job1, trigger1);
  31.     log.info(job1.getKey() + " will run at: " + scheduleTime1 + " and repeat: " + trigger1.getRepeatCount()
  32.              + " times, every " + trigger1.getRepeatInterval() / 1000 + " seconds");

  34.     // job2 will also run 5 times, every 10 seconds
  35.     JobDetail job2 = newJob(ColorJob.class).withIdentity("job2", "group1").build();

  37.     SimpleTrigger trigger2 = newTrigger().withIdentity("trigger2", "group1").startAt(startTime)
  38.         .withSchedule(simpleSchedule().withIntervalInSeconds(10).withRepeatCount(4)).build();

  40.     // pass initialization parameters into the job
  41.     // this job has a different favorite color!
  42.     job2.getJobDataMap().put(ColorJob.FAVORITE_COLOR, "Red");
  43.     job2.getJobDataMap().put(ColorJob.EXECUTION_COUNT, 1);

  45.     // schedule the job to run
  46.     Date scheduleTime2 = sched.scheduleJob(job2, trigger2);
  47.     log.info(job2.getKey().toString() + " will run at: " + scheduleTime2 + " and repeat: " + trigger2.getRepeatCount()
  48.              + " times, every " + trigger2.getRepeatInterval() / 1000 + " seconds");

  50.     log.info("------- Starting Scheduler ----------------");

  52.     // All of the jobs have been added to the scheduler, but none of the jobs
  53.     // will run until the scheduler has been started
  54.     sched.start();

  56.     log.info("------- Started Scheduler -----------------");

  58.     log.info("------- Waiting 60 seconds... -------------");
  59.     try {
  60.       // wait five minutes to show jobs
  61.       Thread.sleep(60L * 1000L);
  62.       // executing...
  63.     } catch (Exception e) {
  64.       //
  65.     }

  67.     log.info("------- Shutting Down ---------------------");

  69.     sched.shutdown(true);

  71.     log.info("------- Shutdown Complete -----------------");

  73.     SchedulerMetaData metaData = sched.getMetaData();
  74.     log.info("Executed " + metaData.getNumberOfJobsExecuted() + " jobs.");

  76.   }
关于有状态的ＪＯＢ。
job1是red，job2是green ，每个job每10秒执行一次，那么假如一个任务需要执行35秒呢？下一次执行在什么时候？
答：按照 trigger 的规则，第 20 秒和第 30 秒分别会有一次预定的触发执行，但是由于是有状态任务，因此实际不会被触发。在第 35秒第一次任务执行完毕时，Quartz 会把第 20秒 和第 30秒的两次触发作为 misfired job 进行处理。对于 misfired job，Quartz 会查看其 misfire 策略是如何设定的，如果是立刻执行，则会马上启动一次执行，如果是等待下次执行，则会忽略错过的任务，而等待下次（即第 6 分钟）触发执行。
有状态的job如果第一次没有执行完，第二次执行的时间错过了，就会被认为是misfire
doUpdateOfMisfiredTrigger调用CronTriggerImpl的updateAfterMisfire方法。
如果misfire设置为MISFIRE_INSTRUCTION_SMART_POLICY或MISFIRE_INSTRUCTION_FIRE_ONCE_NOW就是马上执行。
如果misfire设置为MISFIRE_INSTRUCTION_DO_NOTHING则在下一个周期再执行。
默认是：MISFIRE_INSTRUCTION_SMART_POLICY
可以通过trigger的build方法增加参数实现：
withMisfireHandlingInstructionFireAndProceed().build()
withMisfireHandlingInstructionDoNothing().build()

example5： Job Misfire
Class Name Description
MisfireExample 主程序
StatefulDumbJob 每10秒执行一次

JOB1：每3秒执行一次，执行的任务是延时10秒的。statefulJob是有状态的，上一个任务没执行完，是不会执行的。

点击(此处)折叠或打开

  1. JobDetail job = newJob(StatefulDumbJob.class)
  2.     .withIdentity("statefulJob1", "group1")
  3.     .usingJobData(StatefulDumbJob.EXECUTION_DELAY, 10000L)
  4.     .build();

  6. SimpleTrigger trigger = newTrigger()
  7.     .withIdentity("trigger1", "group1")
  8.     .startAt(startTime)
  9.     .withSchedule(simpleSchedule()
  10.             .withIntervalInSeconds(3)
  11.             .repeatForever())
  12.     .build();

  14. sched.scheduleJob(job, trigger);
JOB2：对于misfire的任务设置为马上执行。默认是smart智能执行。在不同的情况下是不一样的。在Cron情况下都是立即执行。

点击(此处)折叠或打开

  1. job = newJob(StatefulDumbJob.class)
  2.             .withIdentity("statefulJob2", "group1")
  3.             .usingJobData(StatefulDumbJob.EXECUTION_DELAY, 10000L)
  4.             .build();
  5.     
  6.         trigger = newTrigger()
  7.             .withIdentity("trigger2", "group1")
  8.             .startAt(startTime)
  9.             .withSchedule(simpleSchedule()
  10.                     .withIntervalInSeconds(3)
  11.                     .repeatForever()
  12.                     .withMisfireHandlingInstructionNowWithExistingCount()) // set misfire instruction
  13.             .build();
对于SimpleTriggerImpl的MISFIRE_INSTRUCTION_SMART_POLICY

点击(此处)折叠或打开

  1. if (instr == Trigger.MISFIRE_INSTRUCTION_SMART_POLICY) {
  2.             if (getRepeatCount() == 0) {
  3.                 instr = MISFIRE_INSTRUCTION_FIRE_NOW;
  4.             } else if (getRepeatCount() == REPEAT_INDEFINITELY) {
  5.                 instr = MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT;
  6.             } else {
  7.                 // if (getRepeatCount() > 0)
  8.                 instr = MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT;
  9.             }
  10.         }
对于对于CronTriggerImpl的MISFIRE_INSTRUCTION_SMART_POLICY

点击(此处)折叠或打开

  1. if (instr == MISFIRE_INSTRUCTION_SMART_POLICY) {
  2.             instr = MISFIRE_INSTRUCTION_FIRE_ONCE_NOW;
  3.         }

example6： Dealing with Job Exceptions
在JOB1中如果出现异常了，可以通过抛出异常的方式来重新执行一次。

点击(此处)折叠或打开

  1. try {
  2.             int zero = 0;
  3.             int calculation = 4815 / zero;
  4.         }
  5.         catch (Exception e) {
  6.             _log.info("--- Error in job!");
  7.             JobExecutionException e2 =
  8.                 new JobExecutionException(e);
  9.             // this job will refire immediately
  10.             e2.refireImmediately();
  11.             throw e2;
  12.         }
在JOB2中如果出现异常了，可以终止这个任务，以后也不再执行。

点击(此处)折叠或打开

  1. try {
  2.             int zero = 0;
  3.             int calculation = 4815 / zero;
  4.         }
  5.         catch (Exception e) {
  6.             _log.info("--- Error in job!");
  7.             JobExecutionException e2 =
  8.                 new JobExecutionException(e);
  9.             // Quartz will automatically unschedule
  10.             // all triggers associated with this job
  11.             // so that it does not run again
  12.             e2.setUnscheduleAllTriggers(true);
  13.             throw e2;
  14.         }


example7：Interrupting Jobs 
Class Name Description
InterruptExample 主程序
DumbInterruptableJob 可中断JOB，4秒时间，for循环可以被中断
JOB实现InterruptableJob接口，实现中断逻辑。

点击(此处)折叠或打开

  1. public void interrupt() throws UnableToInterruptJobException {
  2.         _log.info("---" + _jobKey + " -- INTERRUPTING --");
  3.         _interrupted = true;
  4.     }
JOB在for循环中，可以被中断执行。

点击(此处)折叠或打开

  1. for (int i = 0; i < 4; i++) {
  2.                 try {
  3.                     Thread.sleep(1000L);
  4.                 } catch (Exception ignore) {
  5.                     ignore.printStackTrace();
  6.                 }
  7.                 
  8.                 // periodically check if we've been interrupted...
  9.                 if(_interrupted) {
  10.                     _log.info("--- " + _jobKey + " -- Interrupted... bailing out!");
  11.                     return; // could also choose to throw a JobExecutionException
  12.                              // if that made for sense based on the particular
  13.                              // job's responsibilities/behaviors
  14.                 }
  15.             }
主程序trigger每5秒触发执行。每7秒触发中断。
由代码sched.interrupt()看出来中断只针对当前sched实例，不是针对集群的。如果是集群，需要每个实例都触发。

点击(此处)折叠或打开

  1. for (int i = 0; i < 50; i++) {
  2.       try {
  3.         Thread.sleep(7000L);
  4.         // tell the scheduler to interrupt our job
  5.         sched.interrupt(job.getKey());
  6.       } catch (Exception e) {
  7.         //
  8.       }
  9.     }


点击(此处)折叠或打开

  1. for (int i = 0; i < 50; i++) {
  2.       try {
  3.         Thread.sleep(7000L);
  4.         // tell the scheduler to interrupt our job
  5.         sched.interrupt(job.getKey());
  6.       } catch (Exception e) {
  7.         //
  8.       }
  9.     }

example8：Fun with Calendars
可以设置一年内的某几天不执行。

点击(此处)折叠或打开

  1. // Add the holiday calendar to the schedule
  2.     AnnualCalendar holidays = new AnnualCalendar();

  4.     // fourth of July (July 4)
  5.     Calendar fourthOfJuly = new GregorianCalendar(2005, 6, 4);
  6.     holidays.setDayExcluded(fourthOfJuly, true);
  7.     // halloween (Oct 31)
  8.     Calendar halloween = new GregorianCalendar(2005, 9, 31);
  9.     holidays.setDayExcluded(halloween, true);
  10.     // christmas (Dec 25)
  11.     Calendar christmas = new GregorianCalendar(2005, 11, 25);
  12.     holidays.setDayExcluded(christmas, true);

  14.     // tell the schedule about our holiday calendar
  15.     sched.addCalendar("holidays", holidays, false, false);

  17.     // schedule a job to run hourly, starting on halloween
  18.     // at 10 am
  19.     Date runDate = dateOf(0, 0, 10, 31, 10);

  21.     JobDetail job = newJob(SimpleJob.class).withIdentity("job1", "group1").build();

  23.     SimpleTrigger trigger = newTrigger().withIdentity("trigger1", "group1").startAt(runDate)
  24.         .withSchedule(simpleSchedule().withIntervalInHours(1).repeatForever()).modifiedByCalendar("holidays").build();

  26.     // schedule the job and print the first run date
  27.     Date firstRunTime = sched.scheduleJob(job, trigger);
example9：Job Listeners
通过监听器可以用于日志、报表的处理。
也可以通过JOB监听器实现在JOB执行前后调用其它JOB，实现简单的任务流程。
监听器需要实现接口JobListener，可以实现jobExecutionVetoed，jobToBeExecuted，jobWasExecuted
代表执行失败、准备执行、执行成功。quartz在JobRunShell类中，在线程执行前后触发调用加入监听器的方法。

点击(此处)折叠或打开

  1. public class Job1Listener implements JobListener {

  3.   private static Logger _log = LoggerFactory.getLogger(Job1Listener.class);

  5.   public String getName() {
  6.     return "job1_to_job2";
  7.   }

  9.   public void jobToBeExecuted(JobExecutionContext inContext) {
  10.     _log.info("Job1Listener says: Job Is about to be executed.");
  11.   }

  13.   public void jobExecutionVetoed(JobExecutionContext inContext) {
  14.     _log.info("Job1Listener says: Job Execution was vetoed.");
  15.   }

  17.   public void jobWasExecuted(JobExecutionContext inContext, JobExecutionException inException) {
  18.     _log.info("Job1Listener says: Job was executed.");

  20.     // Simple job #2
  21.     JobDetail job2 = newJob(SimpleJob2.class).withIdentity("job2").build();

  23.     Trigger trigger = newTrigger().withIdentity("job2Trigger").startNow().build();

  25.     try {
  26.       // schedule the job to run!
  27.       inContext.getScheduler().scheduleJob(job2, trigger);
  28.     } catch (SchedulerException e) {
  29.       _log.warn("Unable to schedule job2!");
  30.       e.printStackTrace();
  31.     }

  33.   }

  35. }


example10：Using Quartz Plug-Ins
插件的方式，是为了不对代码有太大的侵入。把JOB和trigger配置在xml文件上加载。好处是配置修改简单，不需要修改代码。

点击(此处)折叠或打开

  1. <job>
  2.      <name>TestJob2</name>
  3.      <group>GroupOfTestJob2</group>
  4.      <description>This is the description of TestJob2</description>
  5.      <job-class>org.quartz.examples.example10.SimpleJob</job-class>
  6.      <durability>false</durability>
  7.      <recover>true</recover>
  8.      <job-data-map>
  9.      <entry>
  10.      <key>someKey</key>
  11.      <value>someValue</value>
  12.      </entry>
  13.      <entry>
  14.      <key>someOtherKey</key>
  15.      <value>someOtherValue</value>
  16.      </entry>
  17.      </job-data-map>
  18.      </job>
  19.     
  20.      <trigger>
  21.      <simple>
  22.      <name>TestSimpleTrigger2AtTenSecondIntervalAndFiveRepeats</name>
  23.      <group>GroupOfTestJob2Triggers</group>
  24.      <job-name>TestJob2</job-name>
  25.      <job-group>GroupOfTestJob2</job-group>
  26.      <start-time>2010-02-09T10:15:00</start-time>
  27.      <misfire-instruction>MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT</misfire-instruction>
  28.      <repeat-count>5</repeat-count>
  29.      <repeat-interval>10000</repeat-interval>
  30.      </simple>
  31.      </trigger>



example11：Quartz Under High Load
高负载，当线程池中的线程只有10个，而一次生成的定时任务是500个，不够用时执行任务是一个个执行。
而每个任务要延时0到2.5秒随机。11:58:40执行到11:59:46共用了60多秒。平均每个线程执行50个，每秒能执行不到1个。
当线程不够用时，执行的时间就是不准的。 所以需要监控线程池，线程不能满载超过30秒。

点击(此处)折叠或打开

  1. // schedule 500 jobs to run
  2.     for (int count = 1; count <= _numberOfJobs; count++) {
  3.       JobDetail job = newJob(SimpleJob.class).withIdentity("job" + count, "group_1").requestRecovery() // ask scheduler
  4.                                                                                                        // to re-execute
  5.                                                                                                        // this job if it
  6.                                                                                                        // was in
  7.                                                                                                        // progress when
  8.                                                                                                        // the scheduler
  9.                                                                                                        // went down...
  10.           .build();

  12.       // tell the job to delay some small amount... to simulate work...
  13.       long timeDelay = (long) (java.lang.Math.random() * 2500);
  14.       job.getJobDataMap().put(SimpleJob.DELAY_TIME, timeDelay);

  16.       Trigger trigger = newTrigger().withIdentity("trigger_" + count, "group_1")
  17.           .startAt(futureDate((10000 + (count * 100)), IntervalUnit.MILLISECOND)) // space fire times a small bit
  18.           .build();

  20.       sched.scheduleJob(job, trigger);
  21.       if (count % 25 == 0) {
  22.         log.info("...scheduled " + count + " jobs");
  23.       }
  24.     }


requestRecovery的作用在于当scheduler要down了，而任务正在执行时。可以通过scheduler重新执行。



example12：Remote Job Scheduling using RMI
客户端注册JOB和trigger，由服务端执行。客户端和服务端通过RMI通信。
参考：http://www.blogjava.net/xiaohuzi2008/archive/2012/12/04/392408.html


example13： Clustered Quartz
Quartz集群，通过数据库集群。

example14： Trigger Priorities
优先级1-10，优先级越高则同一时间点先执行。


example15： TC Clustered Quartz
基于Terracotta的内存级别的集群。对于大量小任务时使用。
Class Name Description
ClusterExample 主程序
SimpleRecoveryJob
SimpleRecoveryStatefulJob
ClusterExample：
JOB1执行SimpleRecoveryJob每5秒执行一次，共执行21次
JOB2执行SimpleRecoveryJob每5秒执行一次，共执行21次
JOB3执行SimpleRecoveryStatefulJob每3秒执行一次，共执行21次
JOB4执行SimpleRecoveryJob每4秒执行一次，共执行21次
JOB5执行SimpleRecoveryJob每4.5秒执行一次，共执行21次

SimpleRecoveryJob与SimpleRecoveryStatefulJob都是延时执行10秒。
先instance2.bat设置启动参数为：
org.quartz.examples.example15.ClusterExample dontScheduleJobs
就是instance2不加JOB，只由instance1加的JOB，然后instance1与instance2共同运行，以集群的方式运行。
每次循环只会在一个实例上运行。
图1：在instance1上打印

图2：在instance1上打印

图3：在instance2上打印


再看一下job3是StatefulJob，必须在上一次执行完后才能触发。trigger3秒钟触发一次，但是job的执行需要10秒
所以效果就是10秒中执行一次。都是在实例1上执行。





如果instance2也有自己新增的job和trigger的话，instance1与instance2上新增的JOB在集群是共享的。




----
关于terracotta的使用、集群配置、持久化配置、quartz中的源码分析请访问：
http://blog.itpub.net/11627468/viewspace-1771336/

[INFO] 20 八月 09:26:09.842 上午 main [org.terracotta.quartz.DefaultClusteredJob
Store]
Synchronous write locking is [false]

来自 “ ITPUB博客 ” ，链接：https://blog.itpub.net/11627468/viewspace-1774071/ ，如需转载，请注明出处，否则将追究法律责任。

0
0
上一篇： quartz详解4：quartz线程管理
下一篇： 数据库锁：乐观锁和悲观锁，共享锁和排它锁，行级锁和表级锁
请登录后发表评论 登录
全部评论
Tim_java

注册时间：2015-05-26

  • 博文量
    12
  • 访问量
    89865

最新文章

支持我们 作者招募 用户协议 FAQ Contact Us

北京盛拓优讯信息技术有限公司. 版权所有  京ICP备16024965号-8 北京市公安局海淀分局网监中心备案编号：11010802021510 niuxiaotong@pcpop.com 17352615567 未成年人举报专区

广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员

违法和不良信息举报电话:18101376593