OptimisticLockingFailureException caused by jobExecutionDao.updateJobExecution(jobExecution);

[ruudkenter]

I am preparing our codebase for spring-batch 6. One of my job(s), starts multiple steps in parallel.

Bug description
This line is causing a OptimisticLockingFailureException,all submitted threads call jobExecutionDao.updateJobExecution(jobExecution); concurrently, resulting in the exception.

Expected behavior
Not sure, but so is the author: // TODO check if this update is necessary

[fmbenhassine]

Thank you for giving early feedback! There are some corner cases we need to test/refine. We are still in M4, so please expect some bumps. We have two RCs planned until GA, so this is the perfect time to provide such feedback, thank you!

That check should not be necessary (copied from the legacy implementation), but I will plan the verification for 6.0 RC1. I would be grateful if you can provide a minimal example that reproduces the issue, otherwise I will take care of that.

[ruudkenter]

Unfortunately I don't have time to submit a minimal example, I am in the middle of moving houses.

[fmbenhassine]

I am not able to reproduce the issue with parallel steps. I tried with the football sample that loads player/game data in parallel (see https://github.com/spring-projects/spring-batch/blob/main/spring-batch-samples/src/main/java/org/springframework/batch/samples/football/FootballJobParallelStepsConfiguration.java#L150) and also with another sample having more parallel steps:

package org.springframework.batch.samples.helloworld;

import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.job.Job;
import org.springframework.batch.core.job.builder.FlowBuilder;
import org.springframework.batch.core.job.builder.JobBuilder;
import org.springframework.batch.core.job.flow.Flow;
import org.springframework.batch.core.job.flow.support.SimpleFlow;
import org.springframework.batch.core.job.parameters.JobParameters;
import org.springframework.batch.core.launch.JobOperator;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.step.Step;
import org.springframework.batch.core.step.builder.StepBuilder;
import org.springframework.batch.infrastructure.repeat.RepeatStatus;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.SimpleAsyncTaskExecutor;

@Configuration
@EnableBatchProcessing
public class HelloWorldJobConfiguration {

    @Bean
    public Step step1(JobRepository jobRepository) {
        return new StepBuilder(jobRepository).tasklet((contribution, chunkContext) -> {
            System.out.println("Hello world1!");
            return RepeatStatus.FINISHED;
        }).build();
    }

    @Bean
    public Step step2(JobRepository jobRepository) {
        return new StepBuilder(jobRepository).tasklet((contribution, chunkContext) -> {
            System.out.println("Hello world2!");
            return RepeatStatus.FINISHED;
        }).build();
    }

    @Bean
    public Step step3(JobRepository jobRepository) {
        return new StepBuilder(jobRepository).tasklet((contribution, chunkContext) -> {
            System.out.println("Hello world3!");
            return RepeatStatus.FINISHED;
        }).build();
    }

    @Bean
    public Step step4(JobRepository jobRepository) {
        return new StepBuilder(jobRepository).tasklet((contribution, chunkContext) -> {
            System.out.println("Hello world4!");
            return RepeatStatus.FINISHED;
        }).build();
    }

    @Bean
    public Step step5(JobRepository jobRepository) {
        return new StepBuilder(jobRepository).tasklet((contribution, chunkContext) -> {
            System.out.println("Done!");
            return RepeatStatus.FINISHED;
        }).build();
    }

    @Bean
    public Job job(JobRepository jobRepository, Step step1, Step step2, Step step3, Step step4, Step step5) {
        Flow flow1 = new FlowBuilder<SimpleFlow>("flow1").start(step1).build();
        Flow flow2 = new FlowBuilder<SimpleFlow>("flow2").start(step2).build();
        Flow flow3 = new FlowBuilder<SimpleFlow>("flow3").start(step3).build();
        Flow flow4 = new FlowBuilder<SimpleFlow>("flow4").start(step4).build();
        Flow parallelFlow = new FlowBuilder<SimpleFlow>("parallelFlow")
                .start(flow1)
                .split(new SimpleAsyncTaskExecutor())
                .add(flow2, flow3, flow4)
                .build();
        Flow mainFlow = new FlowBuilder<SimpleFlow>("mainFlow").start(parallelFlow).next(step5).build();
        return new JobBuilder("parallelJob", jobRepository).start(mainFlow).build().build();

    }

    public static void main(String[] args) throws Exception {
        ApplicationContext context = new AnnotationConfigApplicationContext(HelloWorldJobConfiguration.class);
        JobOperator jobOperator = context.getBean(JobOperator.class);
        Job job = context.getBean(Job.class);
        jobOperator.start(job, new JobParameters());
    }

}

Still works as expected.

I am not sure which setup leads to an exception on your side, but I need more details to able to proceed and dig deeper.

[ruudkenter]

The issue does not occur in the sample because it makes use of the ResourcelessJobRepository, the locking exception occurs in my case when the SimpleJobRepository is used, backed by H2. Hope that provides the necessary additional information.

[fmbenhassine]

The football job sample that I tried initially uses a JDBC infrastructure backed by H2, see https://github.com/spring-projects/spring-batch/blob/main/spring-batch-samples/src/main/java/org/springframework/batch/samples/football/FootballJobParallelStepsConfiguration.java#L45-L46, yet the test passes with no issues.

And I just gave the same HelloWorldJobConfiguration sample above a try with a JDBC job repository backed by H2 as well and it still passes.

That said, I re-checked if that line is really necessary and in fact it isn't. The samples above and the entire test suite passes without it, so I will remove it. The fix will be shipped in 6.0 RC1 planned for tomorrow, but if you still have the problem, please report it and I will fix it in 6.0 RC2 or the GA. Thanks again for your early feedback!

[ruudkenter]

This sample reproduces the issue: (with h2 on classpath)

`package org.springframework.batch.samples.helloworld;

import org.springframework.batch.core.configuration.support.JdbcDefaultBatchConfiguration;
import org.springframework.batch.core.job.Job;
import org.springframework.batch.core.job.builder.FlowBuilder;
import org.springframework.batch.core.job.builder.JobBuilder;
import org.springframework.batch.core.job.flow.Flow;
import org.springframework.batch.core.job.flow.support.SimpleFlow;
import org.springframework.batch.core.job.parameters.JobParameters;
import org.springframework.batch.core.launch.JobOperator;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.step.Step;
import org.springframework.batch.core.step.builder.StepBuilder;
import org.springframework.batch.infrastructure.repeat.RepeatStatus;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
import org.springframework.jdbc.support.JdbcTransactionManager;

import javax.sql.DataSource;

@configuration
public class HelloWorldJobConfiguration2 extends JdbcDefaultBatchConfiguration {

@Bean
public DataSource dataSource() {
    return new EmbeddedDatabaseBuilder().setType(EmbeddedDatabaseType.H2)
            .addScript("/org/springframework/batch/core/schema-h2.sql")
            .generateUniqueName(true)
            .build();
}

@Bean
public JdbcTransactionManager transactionManager(DataSource dataSource) {
    return new JdbcTransactionManager(dataSource);
}


@Bean
public Step step1(JobRepository jobRepository) {
    return new StepBuilder(jobRepository).tasklet((contribution, chunkContext) -> {
        System.out.println("Hello world1!");
        return RepeatStatus.FINISHED;
    }).build();
}

@Bean
public Step step2(JobRepository jobRepository) {
    return new StepBuilder(jobRepository).tasklet((contribution, chunkContext) -> {
        System.out.println("Hello world2!");
        return RepeatStatus.FINISHED;
    }).build();
}

@Bean
public Step step3(JobRepository jobRepository) {
    return new StepBuilder(jobRepository).tasklet((contribution, chunkContext) -> {
        System.out.println("Hello world3!");
        return RepeatStatus.FINISHED;
    }).build();
}

@Bean
public Step step4(JobRepository jobRepository) {
    return new StepBuilder(jobRepository).tasklet((contribution, chunkContext) -> {
        System.out.println("Hello world4!");
        return RepeatStatus.FINISHED;
    }).build();
}

@Bean
public Step step5(JobRepository jobRepository) {
    return new StepBuilder(jobRepository).tasklet((contribution, chunkContext) -> {
        System.out.println("Done!");
        return RepeatStatus.FINISHED;
    }).build();
}

@Bean
public Job job(JobRepository jobRepository, Step step1, Step step2, Step step3, Step step4, Step step5) {
    Flow flow1 = new FlowBuilder<SimpleFlow>("flow1").start(step1).build();
    Flow flow2 = new FlowBuilder<SimpleFlow>("flow2").start(step2).build();
    Flow flow3 = new FlowBuilder<SimpleFlow>("flow3").start(step3).build();
    Flow flow4 = new FlowBuilder<SimpleFlow>("flow4").start(step4).build();
    Flow parallelFlow = new FlowBuilder<SimpleFlow>("parallelFlow")
            .start(flow1)
            .split(new SimpleAsyncTaskExecutor())
            .add(flow2, flow3, flow4)
            .build();
    Flow mainFlow = new FlowBuilder<SimpleFlow>("mainFlow")
            .start(parallelFlow).next(step5)
            .build();
    return new JobBuilder("parallelJob", jobRepository)
            .start(mainFlow)
            .build()
            .build();

}

public static void main(String[] args) throws Exception {
    ApplicationContext context = new AnnotationConfigApplicationContext(HelloWorldJobConfiguration2.class);
    JobOperator jobOperator = context.getBean(JobOperator.class);
    Job job = context.getBean(Job.class);
    JobParameters jobParameters = new JobParameters();
    jobOperator.start(job, jobParameters);
    JobRepository bean = context.getBean(JobRepository.class);
}

}`