Java 定时任务 Quartz （三）—— 并发

1 前言

根据 Quartz 的设计，一个 Job 可以绑定多个 Trigger，必然会遇到并发的问题。

2 并发

2.1 复现

让我们编写一个并发的例子：

/**
 * @author pancc
 * @version 1.0
 */
public class AcceptConcurrentDemo {

    public static void main(String[] args) throws SchedulerException, InterruptedException {
        JobDetail detail = JobBuilder.newJob(AcceptConcurrentJob.class)
                .withIdentity("detail", "group0")
                .build();


        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("ben_trigger")
                .usingJobData("name", "ben")
                .startNow()
                .build();

        Trigger triggers = TriggerBuilder.newTrigger()
                .withIdentity("mike_trigger")
                .usingJobData("name", "mike")
                .forJob("detail", "group0")
                .startNow()
                .build();


        Scheduler scheduler = new StdSchedulerFactory().getScheduler();

        scheduler.start();
        scheduler.scheduleJob(detail, trigger);
        scheduler.scheduleJob(triggers);
        /*
         * 6 秒钟后关闭
         */
        Thread.sleep(6_000);
        scheduler.shutdown();
    }

    @Data
    public static class AcceptConcurrentJob implements Job {
        private String name;

        @Override
        public void execute(JobExecutionContext context) {
            try {
                System.out.printf("i am %s \n", name);
                Thread.sleep(2_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 

请注意上边的 Details 的 Identity ，设置为 group0.detail，同时我们创建了两个 Trigger，第二个 trigger 在创建的时候通过指定 Identity 绑定到了目标 Job，接着提交这个 Job，与两个 Trigger ，可以看到两个触发器同时出发了 Job 的 execute 方法

 

上边的代码也可以简化为以下形式：

/**
 * @author pancc
 * @version 1.0
 */
public class AcceptConcurrentDemo {

    public static void main(String[] args) throws SchedulerException, InterruptedException {
        JobDetail detail = JobBuilder.newJob(AcceptConcurrentJob.class)
                .withIdentity("detail", "group0")
                .build();


        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("ben_trigger")
                .usingJobData("name", "ben")
                .startNow()
                .build();

        Trigger triggers = TriggerBuilder.newTrigger()
                .withIdentity("mike_trigger")
                .usingJobData("name", "mike")
                .startNow()
                .build();


        Scheduler scheduler = new StdSchedulerFactory().getScheduler();

        scheduler.start();
        scheduler.scheduleJob(detail, Sets.newHashSet(trigger,triggers),true);
        /*
         * 6 秒钟后关闭
         */
        Thread.sleep(6_000);
        scheduler.shutdown();
    }

    @Data
    public static class AcceptConcurrentJob implements Job {
        private String name;

        @Override
        public void execute(JobExecutionContext context) {
            try {
                System.out.printf("i am %s \n", name);
                Thread.sleep(2_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 

2.2 避免并发

为了避免并发，我们可以使用官方提供的注解 @DisallowConcurrentExecution，通过在 类上增加这个注解，我们可以观察到第二个 trigger 进行了排队处理：

/**
 * @author pancc
 * @version 1.0
 */
public class RejectConcurrentDemo {

    public static void main(String[] args) throws SchedulerException, InterruptedException {
        JobDetail detail = JobBuilder.newJob(RejectConcurrentJob.class)
                .withIdentity("detail", "group0")
                .build();


        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("ben_trigger")
                .usingJobData("name", "ben")
                .startNow()
                .build();

        Trigger triggers = TriggerBuilder.newTrigger()
                .withIdentity("mike_trigger")
                .usingJobData("name", "mike")
                .forJob("detail", "group0")
                .startNow()
                .build();


        Scheduler scheduler = new StdSchedulerFactory().getScheduler();

        scheduler.start();
        scheduler.scheduleJob(detail, trigger);
        scheduler.scheduleJob(triggers);
        /*
         * 6 秒钟后关闭
         */
        Thread.sleep(6_000);
        scheduler.shutdown();
    }


    @DisallowConcurrentExecution
    @Data
    public static class RejectConcurrentJob implements Job {
        private String name;

        @Override
        public void execute(JobExecutionContext context) {
            try {
                System.out.printf("i am %s \n", name);
                Thread.sleep(2_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 

 

3 避免并发的原理探索

让我们找到 JobStore 的实现类，在这里是 RAMJobStore，点进去方法 org.quartz.simpl.RAMJobStore#acquireNextTriggers，可以看到这个方法的某个块：

 

 通过对 Job 类上的是否存在  DisallowConcurrentExecution 注解，如果存在，表示拒绝并发执行 execute 方法。如果与即将执行的 Trigger 调用同一个 JobDetail 对象，则将当前 trigger 放入等待列表。

 

之后当前一个 Trigger 执行完毕，将等待中的 Trigger 重新加回去 RAMJobStore 持有的 trigger 列表中，等待下一次调用发生。