Thank you for opening this issue. However, I think there is misuse of the APIs according to the description you gave:

Bug description: If a job is stopped in ChunkListener#afterChunk, termainateOnly is not set.
Steps to reproduce: JobOperator#stop in ChunkListener#afterChunk then it will still run the next chunk.

JobOperator#stop is designed to stop a job from the outside (a separate thread or process), while StepExecution#setTerminateOnly() is designed to stop a job from within the inside.

So if you want to stop a step after a given chunk, you need to set the terminateOnly flag on the step execution and not call JobOperator#stop. Here is a hypothetical example of a chunk listener that should stop the execution if the number of chunks exceeds a given limit:

import org.springframework.batch.core.ChunkListener;
import org.springframework.batch.core.launch.JobOperator;
import org.springframework.batch.core.scope.context.ChunkContext;

public class MyChunkListener implements ChunkListener {

    // private JobOperator jobOperator;
    private int maxChunks;

    // constructor omitted

    @Override
    public void afterChunk(ChunkContext context) {
        if (++maxChunks > 10) {
            // jobOperator.stop(context.getStepContext().getStepExecution().getJobExecutionId()); // this is incorrect 
            context.getStepContext().getStepExecution().setTerminateOnly();
        }
    }
}

Do you see the point?

I got your point. I want to change my question.
Should JobOperator#stop stop the job as soon as possible or do users expect it to behave that way?
If then, we can stop the chunk when it finishes as the next step is not executed when a job is stopped.
And it can be achieved in different ways like checking after a chunk finishes or before the next chunk starts.

I understand that we can use different ways to stop chunk processing in listeners but what if we want to stop the chunk processing not in a listener but only using jobOperator?