Quartz 2 定时任务(二):多线程并发执行与数据共享

3

版权声明:本文由吴仙杰创作整理,转载请注明出处:https://segmentfault.com/a/1190000009128328

1. 禁止同一个 JobDetail 中的多个实例并发执行

Quartz 定时任务默认都是并发执行的,不会等待上一次任务执行完毕,只要间隔时间到就会执行,如果定时任执行太长,会长时间占用资源,导致其它任务堵塞。

禁止并发执行的意思并不是不能同时执行多个 Job,而是不能并发执行同一个 Job Definition(由 JobDetail 定义),但是可以同时执行多个不同的 JobDetail,举例说明,我们有一个 Job 类,叫做 SayHelloJob,并在这个 Job 上加了 @DisallowConcurrentExecution 注解,然后在这个 Job上 定义了很多个 JobDetail,如 sayHelloToJoeJobDetail,sayHelloToMikeJobDetail,那么当 scheduler 启动时,不会并发执行多个 sayHelloToJoeJobDetail 或者 sayHelloToMikeJobDetail,但可以同时执行 sayHelloToJoeJobDetail 跟 sayHelloToMikeJobDetail。

1.1 使用 Spring 整合 Quartz 时

Spring 配置文件中加入:

<!-- false 表示等上一个任务执行完后再开启新的任务 -->
<property name="concurrent" value="false"/>

1.2 Quartz 原生使用时

当不使用 Spring 的时候就需要在 Job 的实现类上加 @DisallowConcurrentExecution 的注解。

2. 同一个 JobDetail 中多个实例的数据共享

@PersistJobDataAfterExecution 是用在 Job 实现类上,表示一个有状态的任务,意思是当正常执行完 Job 后,JobDataMap 中的数据应该被改动,以被下一次调用时用。

注意:当使用 @PersistJobDataAfterExecution 注解时,为了避免并发时,存储数据造成混乱,强烈建议@DisallowConcurrentExecution 注解也加上。

3. 示例

假设定时任务的时间间隔为 3 秒,但 job 执行时间是 10 秒。当设置 @DisallowConcurrentExecution 以后程序会等任务执行完毕后再去执行,否则会在 3 秒时再启动新的线程执行。

当设置 @PersistJobDataAfterExecution 时,在执行完 Job 的 execution 方法后保存 JobDataMap 当中固定数据,以便任务在重复执行的时候具有相同的 JobDataMap;在默认情况下也就是没有设置 @PersistJobDataAfterExecution 的时候每个 job 都拥有独立 JobDataMap。

任务类:

package org.quartz.examples;

import org.quartz.*;

import java.util.Date;

@PersistJobDataAfterExecution
@DisallowConcurrentExecution
public class TaskJob implements Job {

    public static final String NUM_EXECUTIONS = "NumExecutions";
    public static final String EXECUTION_DELAY = "ExecutionDelay";

    /**
     * 静态变量可以保持工作状态,但无法达到预期效果
     */
    private static int _staticCounter = 0;

    /**
     * Quartz 每次执行作业时都会重新实例化,非静态变量无法保持工作状态
     */
    private int _counter = 0;

    /**
     * 需要一个公共的空构造方法,以便 scheduler 随时实例化 job
     */
    public TaskJob() {
    }

    /**
     * 该方法实现需要执行的任务
     */
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.err.println("---> " + context.getJobDetail().getKey() + " 运行中[" + new Date() + "]");

        JobDataMap map = context.getJobDetail().getJobDataMap();

        int executeCount = 0;
        if (map.containsKey(NUM_EXECUTIONS)) {
            executeCount = map.getInt(NUM_EXECUTIONS);
        }

        // 增量计数并将其存储回 JobDataMap,这样可以适当保持工作状态
        executeCount++;
        map.put(NUM_EXECUTIONS, executeCount);

        // 只要有任务执行都会递增,无法达到预期效果
        _staticCounter++;

        // 本地变量递增加,但实际上无法保持工作状态
        _counter++;

        long delay = 5000L;
        if (map.containsKey(EXECUTION_DELAY)) {
            delay = map.getLong(EXECUTION_DELAY);
        }

        try {
            // 模拟一个耗时的 job
            Thread.sleep(delay);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.err.println(context.getJobDetail().getKey() + " 的静态变量 _staticCounter 为:" + _staticCounter + ",非静态变量 scheduler 为:" + _counter);
        System.err.println(context.getJobDetail().getKey() + " 完成了(" + executeCount + ")次 <---");
    }
}

任务调度类:

package org.quartz.examples;

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import java.util.Date;

public class Executer {

    public void run() throws Exception {
        // 通过 schedulerFactory 获取一个调度器
        SchedulerFactory sf = new StdSchedulerFactory();
        Scheduler sched = sf.getScheduler();

        // 创建 jobDetail 实例,绑定 Job 实现类
        // 指明 job 的名称,所在组的名称,以及绑定 job 类
        JobDetail job1 = JobBuilder.newJob(TaskJob.class)
                .withIdentity("statefulJob1", "group1")
                // 给定的键-值对添加到 JobDetail 的 JobDataMap 中
                .usingJobData(TaskJob.EXECUTION_DELAY, 10000L).build();

        // 定义调度触发规则,先立即执行一次,然后每隔 3 秒执行一次
        SimpleTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(3)
                        .repeatForever())
                .build();

        // 把作业和触发器注册到任务调度中
        Date firstRunTime = sched.scheduleJob(job1, trigger);
        System.out.println(job1.getKey() + " 开始运行于:" + firstRunTime + ",重复:" + trigger.getRepeatCount() + " 次,每次间隔 "
                + trigger.getRepeatInterval() / 1000 + " 秒");

        // 任务 job1 方法中拿到的 JobDataMap 的数据是共享的
        // 这里要注意一个情况: 就是 JobDataMap 的数据共享只针对一个 job1 任务
        // 如果在下面在新增加一个任务 那么他们之间是不共享的,比如下面的 job2
        // 创建第二个 JobDetail 实例
        JobDetail job2 = JobBuilder.newJob(TaskJob.class)
                .withIdentity("statefulJob2", "group1")
                // 给定的键-值对添加到 JobDetail 的 JobDataMap 中
                .usingJobData(TaskJob.EXECUTION_DELAY, 10000L)
                .build();

        // 定义调度触发规则,先立即执行一次,然后每隔 3 秒执行一次
        trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger2", "group1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().
                        withIntervalInSeconds(3)
                        .repeatForever()
                        // 指定失效时的策略
                        .withMisfireHandlingInstructionNowWithExistingCount())
                .build();

        // 这个 job2 与 job1 执行的 JobDataMap 不共享
        // 把作业和触发器注册到任务调度中
        firstRunTime = sched.scheduleJob(job2, trigger);
        System.out.println(job2.getKey() + " 开始运行于:" + firstRunTime + ",重复:" + trigger.getRepeatCount() + " 次,每次间隔 "
                + trigger.getRepeatInterval() / 1000 + " 秒");

        // 启动计划程序(实际上直到调度器已经启动才会开始运行)
        sched.start();

        // 等待 60 秒,使我们的 job 有机会执行
        Thread.sleep(60000);

        // 等待作业执行完成时才关闭调度器
        sched.shutdown(true);

        SchedulerMetaData metaData = sched.getMetaData();
        System.out.println("一共运行了:" + metaData.getNumberOfJobsExecuted() + " 个任务");
    }

    public static void main(String[] args) throws Exception {
        Executer example = new Executer();
        example.run();
    }
}

运行结果:

group1.statefulJob1 开始运行于:Wed Apr 19 17:04:22 CST 2017,重复:-1 次,每次间隔 3 秒
group1.statefulJob2 开始运行于:Wed Apr 19 17:04:22 CST 2017,重复:-1 次,每次间隔 3 秒

---> group1.statefulJob2 运行中[Wed Apr 19 17:04:22 CST 2017]
---> group1.statefulJob1 运行中[Wed Apr 19 17:04:22 CST 2017]
group1.statefulJob2 的静态变量 _staticCounter 为:2,非静态变量 scheduler 为:1
group1.statefulJob1 的静态变量 _staticCounter 为:2,非静态变量 scheduler 为:1
group1.statefulJob2 完成了(1)次 <---
group1.statefulJob1 完成了(1)次 <---
---> group1.statefulJob1 运行中[Wed Apr 19 17:04:32 CST 2017]
---> group1.statefulJob2 运行中[Wed Apr 19 17:04:32 CST 2017]
group1.statefulJob1 的静态变量 _staticCounter 为:4,非静态变量 scheduler 为:1
group1.statefulJob1 完成了(2)次 <---
group1.statefulJob2 的静态变量 _staticCounter 为:4,非静态变量 scheduler 为:1
group1.statefulJob2 完成了(2)次 <---
---> group1.statefulJob1 运行中[Wed Apr 19 17:04:42 CST 2017]
---> group1.statefulJob2 运行中[Wed Apr 19 17:04:42 CST 2017]
group1.statefulJob2 的静态变量 _staticCounter 为:6,非静态变量 scheduler 为:1
group1.statefulJob1 的静态变量 _staticCounter 为:6,非静态变量 scheduler 为:1
group1.statefulJob1 完成了(3)次 <---
group1.statefulJob2 完成了(3)次 <---
---> group1.statefulJob1 运行中[Wed Apr 19 17:04:52 CST 2017]
---> group1.statefulJob2 运行中[Wed Apr 19 17:04:52 CST 2017]
group1.statefulJob2 的静态变量 _staticCounter 为:8,非静态变量 scheduler 为:1
group1.statefulJob2 完成了(4)次 <---
group1.statefulJob1 的静态变量 _staticCounter 为:8,非静态变量 scheduler 为:1
group1.statefulJob1 完成了(4)次 <---
---> group1.statefulJob2 运行中[Wed Apr 19 17:05:02 CST 2017]
---> group1.statefulJob1 运行中[Wed Apr 19 17:05:02 CST 2017]
group1.statefulJob2 的静态变量 _staticCounter 为:10,非静态变量 scheduler 为:1
group1.statefulJob1 的静态变量 _staticCounter 为:10,非静态变量 scheduler 为:1
group1.statefulJob2 完成了(5)次 <---
group1.statefulJob1 完成了(5)次 <---
---> group1.statefulJob1 运行中[Wed Apr 19 17:05:12 CST 2017]
---> group1.statefulJob2 运行中[Wed Apr 19 17:05:12 CST 2017]

group1.statefulJob2 的静态变量 _staticCounter 为:12,非静态变量 scheduler 为:1
group1.statefulJob2 完成了(6)次 <---
group1.statefulJob1 的静态变量 _staticCounter 为:12,非静态变量 scheduler 为:1
group1.statefulJob1 完成了(6)次 <---

一共运行了:12 个任务

4. 参考

PS:本文针对的 Quartz 版本为 Quartz 2.2.3。官方下载地址:Quartz 2.2.3 .tar.gz

你可能感兴趣的

载入中...