Job定时任务不允许并行&错过（misfire）策略说明

空~自由

于 2024-08-08 15:36:21 发布

阅读量706

点赞数 25

分类专栏： Java 文章标签： quartz job 任务不允许并发执行 misfire

本文链接：https://blog.csdn.net/liu_xue_xue/article/details/141027458

版权

Java 专栏收录该内容

48 篇文章 3 订阅

订阅专栏

一、trigger 状态转换

二、job 任务不允许并发执行说明

三、MisFire策略说明

一、trigger 状态转换

trigger按其类型不同，分作了SIMPLE、CRON、BLOB等类型，数据库中也有相应的表存储。
先来看下job定时任务调度过程种，trigger的一个状态转换，如下图所示：

二、job 任务不允许并发执行说明

原生quartz不允许并发执行不生效原因：由于任务执行改成走消息总线，任务发送到消息队
列，对quartz而言，就已经调度完成了，后续任务的执行状态无法跟追，导致原生注解@Disa
llowConcurrentExecution不能生效。

从上面trigger状态转换图，我们可以看出，原生quartz控制不允许并发时状态是BLOCKING，
任务完成后，如果下次触发时间为null，则状态变更为COMPLETE，如果下次触发任务不为nul
l，则状态变更为WAITING，进入等待下一次任务的触发。所以我们修改逻辑如下图所示：

任务触发监听的具体实现如下所示：

public class MyTriggerListener extends TriggerListenerSupport {

    private static final Logger logger = LoggerFactory.getLogger(MyTriggerListener.class);

    ScheduledExecutorService sigleThreadPool = Executors.newSingleThreadScheduledExecutor();

    @Autowired
    private TriggersService triggersService;

    @Override
    public String getName() {
        return "myTriggerListener";
    }

    /**
     * 监听触发器的开始
     * @param trigger
     * @param context
     */
    @Override
    public void triggerFired(Trigger trigger, JobExecutionContext context) {
        super.triggerFired(trigger, context);
    }

    /**
     * 监听触发否决
     * @param trigger
     * @param context
     * @return
     */
    @Override
    public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {
        return super.vetoJobExecution(trigger, context);
    }

    /**
     * 触发器完成
     * @param trigger
     * @param context
     * @param triggerInstructionCode
     */
    @Override
    public void triggerComplete(Trigger trigger, JobExecutionContext context, Trigger.CompletedExecutionInstruction triggerInstructionCode) {
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        //是否不允许并发执行
        boolean isConcurrentExectionDisallowed = jobDataMap.getBoolean("isConcurrentExectionDisallowed");
        //如果不允许并发执行，则修改trigger状态为BLOCKED（由于任务执行走消息总线，所以任务是否完成需要业务端控制--任务完成逻辑为：如果下次触发时间不为空，则直接修改trigger状态为WAITING，如果下次触发时间为空，则修改trigger状态为COMPLETE）
        if (isConcurrentExectionDisallowed) {
            TriggerKey triggerKey = trigger.getKey();
            sigleThreadPool.execute(()->{
                try {
                    update(context);
                } catch(InterruptedException e){
                    logger.error(">>>>>>>>>>>> Interrupted! 更新trigger状态异常，triggerName={}，TriggerGroup={}",triggerKey.getName(),triggerKey.getGroup(),e);
                    Thread.currentThread().interrupt();
                } catch (SchedulerException e) {
                    logger.error(">>>>>>>>>>>> 更新trigger状态异常，triggerName={}，TriggerGroup={}",triggerKey.getName(),triggerKey.getGroup(),e);
                }
            });

        } else {
            super.triggerComplete(trigger, context, triggerInstructionCode);
        }
    }

    private void update(JobExecutionContext context) throws SchedulerException, InterruptedException {
        Thread.sleep(20);
        Triggers triggers = new Triggers();
        triggers.setTriggerName(context.getTrigger().getJobKey().getName());
        triggers.setTriggerGroup(context.getTrigger().getJobKey().getGroup());
        triggers.setSchedName(context.getScheduler().getSchedulerName());
        triggers.setTriggerState(Constants.STATE_BLOCKED);
        triggersService.updateTriggers(triggers);
    }
}

任务完成修改触发状态具体实现逻辑（TriggersServiceImpl.java）如下所示：

@Override
    public void updateTriggerJobCompleteStatues(String triggerName, String triggerGroup, boolean isTriggerSuccess){
        Triggers oldTriggers = triggersMapper.selectByNameAndGroup(triggerName,triggerGroup);
        if (oldTriggers == null) {
            return;
        }

        String state = Constants.STATE_ERROR;

        //判断任务触发成功
        if (isTriggerSuccess) {
            // 如果下次触发时间不为空，则直接修改trigger状态为WAITING，如果下次触发时间为空，则修改trigger状态为COMPLETE
            state = oldTriggers.getNextFireTime() == null ? Constants.STATE_COMPLETE : Constants.STATE_WAITING;
        }
        //如果状态不变，则无需更新
        if (state.equals(oldTriggers.getTriggerState())) {
            return;
        }
        // 更新trigger状态
        Triggers triggers = new Triggers();
        triggers.setTriggerName(oldTriggers.getTriggerName());
        triggers.setTriggerGroup(oldTriggers.getTriggerGroup());
        triggers.setSchedName(oldTriggers.getSchedName());
        triggers.setTriggerState(state);
        this.updateTriggers(triggers);
    }

三、MisFire策略说明

当任务执行时间过长、服务停机、任务暂停等原因，导致其超过其下次执行的时间点时，就
会涉及MisFire（失火，错误任务的触发）处理的策略问题。Quartz的任务分为SimpleTrigge
r和CronTrigger，项目中一般使用CronTrigger居多，这边只涉及了CronTrigger的MisFire处
理策略。

MisFire策略常量的定义在类CronTrigger中，列举如下：
MISFIRE_INSTRUCTION_FIRE_ONCE_NOW = 1
MISFIRE_INSTRUCTION_DO_NOTHING = 2
MISFIRE_INSTRUCTION_SMART_POLICY = 0
MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY = -1

根据JavaDoc介绍和官网文档分析，其对应执行策略如下：
MISFIRE_INSTRUCTION_FIRE_ONCE_NOW：立即执行一次，然后按照Cron定义时间点执行
MISFIRE_INSTRUCTION_DO_NOTHING：什么都不做，等待Cron定义下次任务执行的时间点
MISFIRE_INSTRUCTION_SMART_POLICY：智能的策略，针对不同的Trigger执行不同，CronTrigger时为MISFIRE_INSTRUCTION_FIRE_ONCE_NOW
MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY：将所有错过的执行时间点全都补上，例如，任务15s执行一次，执行的任务错过了4分钟，则执行MisFire时，一次性执行4*(60/15)=16次任务

代码中支持根据业务设置MisFire策略
1、定义枚举如下：

public enum CronTriggerMisfirePolicy {

    /**
     * 立即执行一次，然后按照Cron定义时间点执行
     */
    MISFIRE_INSTRUCTION_FIRE_ONCE_NOW (1),

    /**
     * 什么都不做，等待Cron定义下次任务执行的时间点
     */
    MISFIRE_INSTRUCTION_DO_NOTHING(2),

    /**
     * 智能的策略，针对不同的Trigger执行不同，CronTrigger时为MISFIRE_INSTRUCTION_FIRE_ONCE_NOW
     */
    MISFIRE_INSTRUCTION_SMART_POLICY(0),

    /**
     * 将所有错过的执行时间点全都补上，例如，任务15s执行一次，执行的任务错过了4分钟，则执行MisFire时，一次性执行4*(60/15)= 16次任务
     */
    MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY(-1);

    private int value;

    CronTriggerMisfirePolicy(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

}

2、JobDetailDto 新增错失策略属性

/**
* CronTrigger misfire策略
*/
private CronTriggerMisfirePolicy cronTriggerMisfirePolicy;

3、QuartzJobServiceImpl.java 中新增不同misfire策略处理逻辑

private CronScheduleBuilder handleCronScheduleMisfirePolicy(CronTriggerMisfirePolicy cronTriggerMisfirePolicy, CronScheduleBuilder cb) {
        if (cronTriggerMisfirePolicy == null) {
            return cb;
        }
        switch (cronTriggerMisfirePolicy) {
            case MISFIRE_INSTRUCTION_SMART_POLICY:
                return cb;
            case MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY:
                // 以错过的第一个频率时间立刻开始执行
                // 重做错过的所有频率周期后
                // 当下一次触发频率发生时间大于当前时间后，再按照正常的Cron频率依次执行
                return cb.withMisfireHandlingInstructionIgnoreMisfires();
            case MISFIRE_INSTRUCTION_FIRE_ONCE_NOW:
                //以当前时间为触发频率立刻触发一次执行
                //然后按照Cron频率依次执行
                return cb.withMisfireHandlingInstructionFireAndProceed();
            case MISFIRE_INSTRUCTION_DO_NOTHING:
                // 不触发立即执行
                // 等待下次Cron触发频率到达时刻开始按照Cron频率依次执行
                return cb.withMisfireHandlingInstructionDoNothing();
            default:
                logger.warn(">>>>>>>>>>>>>>>>>>>>>>>>The task misfire policy '{}' cannot be used in cron schedule tasks", cronTriggerMisfirePolicy);
                return cb;
        }
    }

修改addQuartz方法，如下