removing duplicate code shared between sync and async implementations

Given that I have an Processor interface:

public interface Processor {
    PBResponse process(PBEntity pbEntity);
}

And I have two implementation in my framework project, one synchronous:

@Service("Synchronous")
public class SyncProcessor implements Processor {

    private final PBRepository pbRepository;
    private final JobRunner jobRunner;

    public SyncProcessor(PBRepository pbRepository, JobRunner jobRunner) {
        this.pbRepository = pbRepository;
        this.jobRunner = jobRunner;
    }

    @Override
    public PBResponse process(PBEntity pbEntity) {
       pbRepository.save(pbEntity);
       //other business logic and run job
        jobRunner.runJob(pbEntity);
    }
}

The Other Async:

public class AsyncProcessor implements Processor {

    private final PBRepository pbRepository;
    private final JobRunner jobRunner;

    private ExecutorService executorService = Executors.newSingleThreadExecutor();

    public SyncProcessor(PBRepository pbRepository, JobRunner jobRunner) {
        this.pbRepository = pbRepository;
        this.jobRunner = jobRunner;
    }

    @Override
    public PBResponse process(PBEntity pbEntity) {
        pbRepository.save(pbEntity);
        executorService.execute(new PBJobRunTask(pbRepository, jobRunner, pbEntity));
        return new PBResponse(...) //initial incomplete Response
    }

    private class PBJobRunTask implements Runnable {
        private final PBSFeedRepository pbsFeedRepository;
        private final JobRunner jobRunner;
        private final PBEntity pbEntity;

        public PBJobRunTask(PBRepository pbRepository, JobRunner jobRunner, PBEntity pbEntity) {
            //initialise
        }

        @Override
        public void run() {
            //other business logic and run job
            jobRunner.runJob(pbEntity);
        }
    }
}

Processing of a request is identical between both sync and async implementations. The only difference is the logic is executed with an ExecutorService with async implementation.

The processing logic is repeated in both Synchronous and Asynchronous implementations within the Runnable run() method:

   //duplicated
   pbRepository.save(pbEntity);
        //other business logic and run job
        jobRunner.runJob(pbEntity);

I need some help remove this duplicated where both these implementation can share. I am not sure whether inject Synchronous class into Async in a good practice as they are both implementations of Processor.

What would be ideal and a good pattern to share the business logic between two classes. We have the repository and JobRunner which also sits in both implementations and perhaps they can move also?

Thanks in advance

You can use template method pattern.

Define abstract class AbstractProcessor and implement Processor interface as final. In process(PBEntity pbEntity) define steps as protected method with default/no implementation and in child class override specific step

public abstract class AbstractProcessor implements Processor {

  private final PBRepository pbRepository;
  private final JobRunner jobRunner;

  public AbstractProcessor(PBRepository pbRepository, JobRunner jobRunner) {
    this.pbRepository = pbRepository;
    this.jobRunner = jobRunner;
  }

  @Override
  public final PBResponse process(PBEntity pbEntity) {
    someBusinessLogic(pbEntity);
    execute(pbEntity);
    return new PBResponse();
  }

  protected void someBusinessLogic(PBEntity pbEntity) {
      pbRepository.save(pbEntity);
      //some other business logic
  }
  protected void execute(PBEntity pbEntity) {

  }

}

Example child class -

@Service("Synchronous")
class SyncProcessor extends AbstractProcessor {

    public SyncProcessor(PBRepository pbRepository, JobRunner jobRunner) {
        super(pbRepository,jobRunner);
    }

    @Override
    public void execute(PBEntity pbEntity) {
        getJobRunner().runJob(pbEntity);

    }
}