Unable to use Job Scope beans in a multi-threaded or partitioned step [BATCH-2269]

[spring-projects-issues]

David Geary opened BATCH-2269 and commented

Attempting to access a JobScope bean from a worker thread in a thread pool as part of a multi-threaded or partitioned step gives the following exception

Caused by: java.lang.IllegalStateException: No context holder available for job scope
        at org.springframework.batch.core.scope.JobScope.getContext(JobScope.java:153)
        at org.springframework.batch.core.scope.JobScope.get(JobScope.java:92)
        at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:338)

This is due to the fact the JobExecution is stored in a ThreadLocal and it isn't set up on the worker threads.

---

Affects: 3.0.1

Reference URL: http://stackoverflow.com/questions/24558703/multi-threaded-acces-to-job-scope-beans-in-spring-batch-3-0

18 votes, 21 watchers

[spring-projects-issues]

tulsiram commented

Because ,in yours Thread Local has current version of Job Execution which is located at
"org.springframework.batch.core.scope.context.SynchronizationManagerSupport"

[spring-projects-issues]

Carlos Silva commented

We also had this problem, so we define a tweaked TaskExecutor that registers each thread in the JobSynchronizationManager, and in finally it releases it:

    TaskExecutor taskExecutor() {
        return new SimpleAsyncTaskExecutor() {
            @Override
            protected void doExecute(Runnable task) {
                //gets the jobExecution of the configuration thread
                def jobExecution = JobSynchronizationManager.context.jobExecution
                super.doExecute(new Runnable() {
                    @Override
                    void run() {
                        JobSynchronizationManager.register(jobExecution)

                        try {
                            task.run()
                        } finally {
                            JobSynchronizationManager.release()
                        }
                    }
                })
            }
        }
    }

Then we use that executor:

new FlowBuilder<SimpleFlow>('readControlFilesFlow')
               .start(firstStep)
               .split(taskExecutor())
               .add(anotherStep)
               .end()

[spring-projects-issues]

Gustavo Lopes commented

Just a small correction. The call to ::release() should be to ::close() instead.

[spring-projects-issues]

David Johnson commented

This workaround executor doesn't seem to work with spring-batch 3.0.6 under java 8.

JobSynchronizationManager.context is always null, so the method fails.

Is there a cleaner or more complete workaround?

[spring-projects-issues]

Ali Shahbour commented

This is how it worked with me in spring boot 1.4.2 and spring batch 3.0.7 .

I did StepExecutionListener on the slave step

public class PartialStepListener implements StepExecutionListener {

    @Autowired
    Stepsp step;

    @Autowired
    Jobsp job;

    @Override
    public void beforeStep(StepExecution stepExecution) {
        JobSynchronizationManager.register(stepExecution.getJobExecution());
    }

    @Override
    public ExitStatus afterStep(StepExecution stepExecution) {
        ExitStatus es = stepExecution.getExitStatus();
        int i = step.getStepCount() + 1;
        step.setStepCount(i);
        int j = job.getJobCount() + 1;
        job.setJobCount(j);
        JobSynchronizationManager.release();
        JobSynchronizationManager.close();
        return es;
    }
}

[spring-projects-issues]

Oleksandr Gavenko commented

• https://stackoverflow.com/questions/28943123/access-jobscope-bean-in-spring-batch-with-partitioned-step
• https://stackoverflow.com/questions/24558703/multi-threaded-acces-to-job-scope-beans-in-spring-batch-3-0

[davidvella]

Carlos Silva commented

We also had this problem, so we define a tweaked TaskExecutor that registers each thread in the JobSynchronizationManager, and in finally it releases it:

    TaskExecutor taskExecutor() {
        return new SimpleAsyncTaskExecutor() {
            @Override
            protected void doExecute(Runnable task) {
                //gets the jobExecution of the configuration thread
                def jobExecution = JobSynchronizationManager.context.jobExecution
                super.doExecute(new Runnable() {
                    @Override
                    void run() {
                        JobSynchronizationManager.register(jobExecution)

                        try {
                            task.run()
                        } finally {
                            JobSynchronizationManager.release()
                        }
                    }
                })
            }
        }
    }

Then we use that executor:

new FlowBuilder<SimpleFlow>('readControlFilesFlow')
               .start(firstStep)
               .split(taskExecutor())
               .add(anotherStep)
               .end()

Still an issue. Was able to resolve with a similar fix:

    @Bean
    public TaskExecutor taskExecutor(){
        return new SimpleAsyncTaskExecutor(){
            @Override
            protected void doExecute(Runnable task) {
                //gets the jobExecution of the configuration thread
                JobExecution jobExecution = JobSynchronizationManager.getContext().getJobExecution();
                super.doExecute(() -> {
                    JobSynchronizationManager.register(jobExecution);

                    try {
                        task.run();
                    } finally {
                        JobSynchronizationManager.release();
                    }
                });
            }
        };
    }

    @Bean
    public Step batchStep() {
        return stepBuilderFactory.get("processAccounts")
                .<?, ?> chunk(1)
                .reader(reader())
                .processor(processor())
                .writer(writer())
                .taskExecutor(taskExecutor())
                .build();
    }

[f3l1xss]

is this planned to be fixed?