Elasticjob执行job幂等

ElasticJob的幂等机制,是指作业分片执行的幂等,他需要做到以下两点:

  • 同一个分片在当前作业实例上不会被重复执行

  • 一个作业分片不能同时在多个作业实例上执行

如何实现幂等

场景模拟:存在任务A执行周期为10s一次。正常情况下任务处理耗时3-5s。但是某一时刻因为数据量突然增大或者因为数据库压力,导致任务耗时超过了10s。在该过程中,任务每10s调度一次,如果没有幂等,那么会存在一个任务同时多个调度的情况,处理相同的数据。

ElasticJob任务执行:com.dangdang.ddframe.job.executor.AbstractElasticJobExecutor#execute()

Java 复制代码
public final void execute() {
        ...
          // 获取当前作业服务器的分片上下文
        ShardingContexts shardingContexts = jobFacade.getShardingContexts();
        //是否允许可以发送作业事件
        if (shardingContexts.isAllowSendJobEvent()) {
            // 发布作业状态追踪事件
            jobFacade.postJobStatusTraceEvent(shardingContexts.getTaskId(), State.TASK_STAGING, String.format("Job '%s' execute begin.", jobName));
        }
        // 在一个调度任务触发后如果上一次任务还未执行,则需要设置该分片状态为mirefire,表示错失了一次任务执行
        if (jobFacade.misfireIfRunning(shardingContexts.getShardingItemParameters().keySet())) {
            if (shardingContexts.isAllowSendJobEvent()) {
                jobFacade.postJobStatusTraceEvent(shardingContexts.getTaskId(), State.TASK_FINISHED, String.format(
                        "Previous job '%s' - shardingItems '%s' is still running, misfired job will start after previous job completed.", jobName, 
                        shardingContexts.getShardingItemParameters().keySet()));
            }
            return;
        }
        ...
    }

接下来主要看一下jobFacade.misfireIfRunning的实现逻辑

Java 复制代码
 public boolean misfireIfHasRunningItems(Collection<Integer> items) {
       // 没有分片正在运行,返回false,此次任务调度正常进行,否则设置mirefire
       if (!this.hasRunningItems(items)) {
            return false;
        } else {
            this.setMisfire(items);
            return true;
        }
    }

如果存在未完成调度的分片,则调用setMisfire(items)方法。如何判断是否有未完成调度的分片呢,看看hasRunningItems(items)的实现逻辑。

Java 复制代码
public boolean hasRunningItems(Collection<Integer> items) {
        LiteJobConfiguration jobConfig = this.configService.load(true);
        if (null != jobConfig && jobConfig.isMonitorExecution()) {
            Iterator i$ = items.iterator();

            int each;
            do {
                if (!i$.hasNext()) {
                    return false;
                }

                each = (Integer)i$.next();
            } while(!this.jobNodeStorage.isJobNodeExisted(ShardingNode.getRunningNode(each)));
            // ShardingNode.getRunningNode(each)
          /*
            public static String getRunningNode(int item) {
                return String.format("sharding/%s/running", item);
            }*/
            return true;
        } else {
            return false;
        }
    }

在Elasticjob开启monitorExecution的机制下,分片任务开始时会创建sharding/分片/running节点,任务完成后删除该节点。所以上述代码中,可以看出来,可以通过是否存在该分片的节点来判断是否有分片正在运行。

同时,调用setMisfire(items)方法的时候,根据代码判断,setMisfire(items)方法为分配给该实例下的所有分片创建持久节点/shading/{item}/misfire节点,只要分配给该实例的任何一分片未执行完毕,则在该实例下的所有分片都增加misfire节点,然后忽略本次任务触发执行,等待任务结束后再执行。

Java 复制代码
    public void setMisfire(Collection<Integer> items) {
        Iterator i$ = items.iterator();

        while(i$.hasNext()) {
            int each = (Integer)i$.next();
            this.jobNodeStorage.createJobNodeIfNeeded(ShardingNode.getMisfireNode(each));
        }
        // ShardingNode.getMisfireNode(each)
        /**
            static String getMisfireNode(int item) {
                return String.format("sharding/%s/misfire", item);
            }
        */

    }

在该执行方法中(com.dangdang.ddframe.job.executor.AbstractElasticJobExecutor#execute())

Java 复制代码
//执行job        
execute(shardingContexts, JobExecutionEvent.ExecutionSource.NORMAL_TRIGGER);

//  如果存在Misfire节点,则清除该节点
while (jobFacade.isExecuteMisfired(shardingContexts.getShardingItemParameters().keySet())) {    
  // 清除Misfire节点
  jobFacade.clearMisfire(shardingContexts.getShardingItemParameters().keySet());
  execute(shardingContexts, JobExecutionEvent.ExecutionSource.MISFIRE);
 }

总结:在下一个调度周期到达之后,只要发现这个分片的任何一个分片正在执行,则为该实例分片的所有分片都设置为misfire,等任务执行完毕后,再统一执行下一次任务调度。