如何防止Spring批次启动新的作业实例？

Question

想法是，如果已经运行相同的作业，则不要启动作业。

作业资源管理器是简单注入到类中，其中是用于运行的计划方法

public class JobClass {

    private final Job job;
    private final JobExplorer jobExplorer;
    private final JobLauncher jobLauncher;

    public JobMain(Job job,
                   JobLauncher jobLauncher,
                   JobExplorer jobExplorer) {
        this.job = job;
        this.jobLauncher = jobLauncher;
        this.jobExplorer = jobExplorer;
    }

然后它被执行

    @Scheduled("0 */5 * ? * *")
    public void startJob() {
        JobParameters jobParameters = new JobParametersBuilder()
                    .addString("jobName", String.valueOf(instant.toEpochMilli()))
                    .toJobParameters();
        jobLauncher.run(job, jobParameters);
    }

这不是解决方案，因为如果JVM在作业运行时停止，这将与当前作业运行相同：

jobExplorer.findRunningJobExecutions("jobName")

它将找到所有带有exitCode的作业ExitStatus.UNKNOWN.

在我看来，有3种解决方案：

解决方案一：

停止以前运行的未完成作业并运行新作业PROS：一切都干净，只有一个属性

续：失去当前作业的当前执行

@Scheduled("0 */5 * ? * *")
public void startJob() {
    (JobExecution jobExecution: jobExplorer.findRunningJobExecutions("jobName")) jobExecution.stop();
    ...
}

解决方案2

计算最近运行的作业之间的时间，如这里所述，如果有任何不启动新作业：https://stackoverflow.com/a/23218986/1182625

优点：一切都很干净

CONT：必须有两倍的属性（5*60*1000和“0*/5 * ? * *")

Set<JobExecution> jobExecutions = jobExplorer.findRunningJobExecutions("jobName");
        if(jobExecutions.size()>1){
            Long currentTime = (new Date()).getTime();
            for(JobExecution execution : jobExecutions) {
                if((currentTime - execution.getStartTime().getTime()) < 5*60*1000) {
                    return;
                } else {
                    execution.stop();
                }
            }

        }

解决方案3

想法很简单，添加静态（在类的实例之间共享）易失性（在线程之间共享）标志，它将指示当前运行PROS的任何作业：只有一个属性

CONT：需要2个侦听器，以及不知道在多节点环境中反应如何的易失性静态变量

    private static volatile boolean FINISHED = true;

然后简单添加监听器并完成修改方法：

// reset FINISHED after job is done
     @AfterJob
     public void afterJob() {
         FINISHED = true;
     }

    public void setFinished() {
        this.FINISHED = true;
    }

简单地添加：

    @Scheduled("0 */5 * ? * *")
    public void startJob() {
    if(!FINISHED) return;
    FINISHED = false;
    ...
    }

最后添加StepListener

public MyStepListener() {
...
    @AfterStep
    public ExitStatus afterStep(StepExecution stepExecution) {
    if(stepExecution.getExitStatus().getExitCode().equalsIgnoreCase(ExitStatus.FAILED.getExitCode()))  (new JobMain()).setFinished();
    return null;
    }

Answer 1

想法是，如果已经运行相同的作业，则不要启动作业。

根据设计，Spring Batch将阻止这种情况。如果您尝试在同一作业实例正在运行的作业执行时启动它，您将获得一个JobExecutionAlreadyRunningException。

Answer 2

好吧，我想我走得很远，可能是KISS。

保持简单

所以，要实现这一点，如果您想使用属性文件中的值，可以简单地将fixedDelay或fixedStringDelay放在@Scheduled注释中。

@Scheduled(initialDelay = 3*60*1000, fixedDelayString ="${job.fixed_delay}")

这样我就实现了在同一时间我不会有一个以上相同工作的实例。我只在特定时间(如午夜或凌晨)丢掉工作...)