Elasticjob执行job幂等

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

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

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

如何实现幂等

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

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

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
的实现逻辑

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

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

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节点，然后忽略本次任务触发执行，等待任务结束后再执行。

    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()
)

//执行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，等任务执行完毕后，再统一执行下一次任务调度。