zoukankan      html  css  js  c++  java

  • 初识Quartz（二）

    简单作业：

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    package quartz_project.example2;
     
    import java.util.Date;
     
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.quartz.JobKey;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
     
    /**
     * 需要在特定的日期或者时间启动，
     * 并且期望以一个可能的间隔时间重复执行 n 次的Job
     * 
     * @author caijw
     */
    public class SimpleJob implements Job {
         
        private static Logger _log = LoggerFactory.getLogger(SimpleJob.class);
     
        @Override
        public void execute(JobExecutionContext ctx) throws JobExecutionException {
            JobKey jobKey = ctx.getJobDetail().getKey();
            _log.info("SimpleJob says: " + jobKey + " executing at " + new Date());
        }
     
    }

    注：由于代码较长，本文将按照任务分开解释，第一段代码将做为下列任务的运行环境。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    Logger log = LoggerFactory.getLogger(SimpleTriggerExample.class);
     
    log.info("----- Initializing --------");
    //第一步我们必须获取一个调度器
    SchedulerFactory sf = new StdSchedulerFactory();
    Scheduler sched = sf.getScheduler();
     
    log.info("----- Initialization complete -------");
     
    //作业的执行时间（这里需要注意，下面详细说明）
    Date startTime = DateBuilder.nextGivenSecondDate(null, 15);
     
    log.info("----- scheduling jobs --------");

        注意：Date startTime = DateBuilder.nextGivenSecondDate(null, 15);

            每分钟以15秒为单位，在当前时间的在下一个15秒开始。例如：当前时间为18：20：02秒，那么作业将在18：20：15秒执行。

    一、在startTime时间点执行job1

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    JobDetail job = JobBuilder.newJob(SimpleJob.class)
        .withIdentity("job1", "group1")
        .build();
     
    SimpleTrigger trigger = (SimpleTrigger) TriggerBuilder.newTrigger()
        .withIdentity("trigger1", "group1")
        .startAt(startTime).build(); //该触发器将在startTime时执行作业
     
    Date ft = sched.scheduleJob(job, trigger);
     
    log.info(job.getKey() + " will run at: " + ft +
            " and repeat: " + trigger.getRepeatCount() + 
            " times, every " + trigger.getRepeatInterval() / 1000 + " seconds");

    二、在startTime时间点执行job2

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    job = JobBuilder.newJob(SimpleJob.class)
        .withIdentity("job2", "group1")
        .build();
     
    trigger = (SimpleTrigger) TriggerBuilder.newTrigger()
        .withIdentity("trigger2", "group1")
        .startAt(startTime).build();
     
    ft = sched.scheduleJob(job, trigger);
    log.info(job.getKey() + " will run at: " + ft +
            " and repeat: " + trigger.getRepeatCount() + 
            " times, every " + trigger.getRepeatInterval() / 1000 + " seconds");

       通过下面的输出结果可以发现：该作业是以多线程并发运行的。

    ?
    1
    2
    3
    4
    5
    [INFO] 27 一月 09:19:15.000 下午 DefaultQuartzScheduler_Worker-2 [quartz_project.example2.SimpleJob]
    SimpleJob says: group1.job1 executing at Mon Jan 27 21:19:15 CST 2014
     
    [INFO] 27 一月 09:19:15.000 下午 DefaultQuartzScheduler_Worker-3 [quartz_project.example2.SimpleJob]
    SimpleJob says: group1.job2 executing at Mon Jan 27 21:19:15 CST 2014

    三、在startTime时间点执行job3，以后每隔10s运行一次，重复10次，共运行11次。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    job = JobBuilder.newJob(SimpleJob.class)
        .withIdentity("job3", "group1")
        .build();
     
    trigger = TriggerBuilder.newTrigger()
        .withIdentity("trigger3", "group1")
        .startAt(startTime)
        .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(10) //时间间隔10s
                .withRepeatCount(10)) //重复次数10次
        .forJob(job).build();
     
    ft = sched.scheduleJob(job, trigger);
    log.info(job.getKey() + " will run at: " + ft +
            " and repeat: " + trigger.getRepeatCount() + 
            " times, every " + trigger.getRepeatInterval() / 1000 + " seconds");

    三、为job3重新绑定trigger，在startTime时间点执行job3，以后每隔10s运行一次，重复2次。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    trigger = TriggerBuilder.newTrigger()
        .withIdentity("trigger3", "group2") //记得换成group2不然就不唯一了
        .startAt(startTime)
        .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(10)
                .withRepeatCount(2))
        .forJob(job).build();
    ft = sched.scheduleJob(trigger); //注意这里，不可以使用sched.scheduleJob(job, trigger)
    log.info(job.getKey() + " will [also] run at: " + ft +
            " and repeat: " + trigger.getRepeatCount() + 
            " times, every " + trigger.getRepeatInterval() / 1000 + " seconds");

    四、在当前时间的5分钟后执行job5。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    job = JobBuilder.newJob(SimpleJob.class)
        .withIdentity("job5", "group1")
        .build();
     
    trigger = (SimpleTrigger) TriggerBuilder.newTrigger()
        .withIdentity("trigger5", "group1")
        .startAt(DateBuilder.futureDate(5, IntervalUnit.MINUTE)) //当前时间的5分钟后
        .build();
     
    ft = sched.scheduleJob(job, trigger);
    log.info(job.getKey() + " will run at: " + ft +
            " and repeat: " + trigger.getRepeatCount() + 
            " times, every " + trigger.getRepeatInterval() / 1000 + " seconds");

    五、在startTime时间点执行job6，以后每隔40s运行一次，无限执行下去。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    job = JobBuilder.newJob(SimpleJob.class)
        .withIdentity("job6", "group1")
        .build();
     
    trigger = TriggerBuilder.newTrigger()
        .withIdentity("trigger6", "group1")
        .startAt(startTime)
        .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(40)
                .repeatForever()) //无限次
        .forJob(job).build();
     
    ft = sched.scheduleJob(job, trigger);
    log.info(job.getKey() + " will run at: " + ft +
            " and repeat: " + trigger.getRepeatCount() + 
            " times, every " + trigger.getRepeatInterval() / 1000 + " seconds");

    六、所有的作业都被加到了调度器中，但是只有调度器启动作业才会开始执行

    ?
    1
    2
    3
    log.info("------ starting scheduler -------");
    sched.start();//启动调度器
    log.info("------ started scheduler -------");

    七、在调度器启动后，仍可以添加作业进去：在startTime时间点执行job7，以后每隔5分钟运行一次，执行20次。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    job = JobBuilder.newJob(SimpleJob.class)
        .withIdentity("job7", "group1")
        .build();
     
    trigger = TriggerBuilder.newTrigger()
        .withIdentity("trigger7", "group1")
        .startAt(startTime)
        .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInMinutes(5)
                .withRepeatCount(20))
        .build();
     
    ft = sched.scheduleJob(job, trigger);
    log.info(job.getKey() + " will run at: " + ft +
            " and repeat: " + trigger.getRepeatCount() + 
            " times, every " + trigger.getRepeatInterval() / 1000 + " seconds");

    八、作业可以不需要触发器，而是通过手动启动。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    job = JobBuilder.newJob(SimpleJob.class)
        .withIdentity("job8", "group1")
        .storeDurably() //即使没有Trigger关联时，也不需要删除该JobDetail
        .build();
     
    sched.addJob(job, true);
     
    log.info("'Manually' triggering job8...");
    sched.triggerJob(JobKey.jobKey("job8", "group1"));//通过手动触发，执行作业8

    九、重新注册job7，利用线程休眠模拟过了执行时间，效果就是该作业会马上执行一次。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    log.info("------- Waiting 30 seconds... --------------");
     
    try {
        Thread.sleep(30L * 1000L);
    } catch (Exception e) {
        log.error(e.getMessage(), e);
    }
     
    log.info("---------- rescheduling... -------");
    trigger = TriggerBuilder.newTrigger()
        .withIdentity("trigger7", "group1")
        .startAt(startTime)
        .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInMinutes(5)
                .withRepeatCount(20))
        .build();
     
    ft = sched.rescheduleJob(trigger.getKey(), trigger);
    log.info("job7 rescheduled to run at: " + ft);

        注意： ft = sched.rescheduleJob(trigger.getKey(), trigger); 表示在sched.start()之后调用，可以在job开始后重新定义trigger，然后重新注册。

    十、五分钟后关闭调度器，所以没有执行完的作业将终止。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    log.info("------- Waiting five minutes... ------------");
    try {
        // wait five minutes to show jobs
        Thread.sleep(300L * 1000L); 
        // executing...
    } catch (Exception e) {
    }
     
    log.info("------- Shutting Down ---------------------");
     
    sched.shutdown(true);
     
    log.info("------- Shutdown Complete -----------------");

    十一、查看这段时间内，总执行了多少任务。

    ?
    1
    2
    SchedulerMetaData metaData = sched.getMetaData();
    log.info("Executed " + metaData.getNumberOfJobsExecuted() + " jobs.");
  • 相关阅读:
    5G 需要换 SIM 卡吗？
    多线程设计模式
    4G LTE/EPC UE 的附着与去附着
    4G EPS 的网络协议栈
    MYSQL远程登录权限设置 ，可以让Navicat远程连接服务器的数据库
    MYSQL远程登录权限设置 ，可以让Navicat远程连接服务器的数据库
    MYSQL远程登录权限设置 ，可以让Navicat远程连接服务器的数据库
    2018年要学习的10大Python Web框架
    2018年要学习的10大Python Web框架
    2018年要学习的10大Python Web框架
  • 原文地址：https://www.cnblogs.com/kabi/p/5239814.html
Copyright © 2011-2022 走看看