@Controller
@ApiIgnore
public class Test {    
    @Autowired
    private JobService jobService;

    @RequestMapping(value = "/mytest.html", method= RequestMethod.GET)
    public void processUpload() throws Exception{
        jobService.makeJob();
    }
}

@Controller
public class StopJob {   
    @Autowired
    private EventProducer eventProducer;

    @RequestMapping(value = "/stopJob.html", method= RequestMethod.GET)
    public void processUpload() throws Exception{
        eventProducer.stopWork("my-job");
    }
}

@Service
public class JobService {
    @Autowired
    private EventProducer eventProducer;

    private static final Logger log = Logger.getLogger(JobService.class);

    public void makeJob(){
        EventListener listener = new EventListener(){
            public void stopJob(RelationshipEvent myEvent){
                log.info("stopJob() " + myEvent.getMessage());
            }
        };
        eventProducer.addMyListener(listener);

        while (true){
            try{
                Thread.sleep(5000);
            }catch (InterruptedException ex){}
            log.info("make job");
        }
    }
}

public class EventProducer {
    private ArrayList<EventListener> listeners = new ArrayList<>();
    public void addMyListener(EventListener listener){
        listeners.add(listener);
    }

    public ArrayList<EventListener> getEventListeners(){
        return listeners;
    }

    public void removeEventListener(EventListener listener){
        listeners.remove(listener);
    }

    protected void fireStop(String message){
        RelationshipEvent ev = new RelationshipEvent(this, message);
        for(EventListener listener : listeners)
            listener.stopJob(ev);
    }

    public void stopWork(String workName){
        fireStop("stop work " + workName);
    }
}

@Controller
public class StartJob {
    @Autowired
    private JobService jobService;

    @RequestMapping(value = "/startJob.html", method= RequestMethod.GET)
    public void processUpload() throws Exception{
        if (SecurityContextHolder.getContext().getAuthentication().getPrincipal().equals("anonymousUser")){
            throw new AccessDeniedException("anonymous is not allow");
        }

        CustomUserDetails customUserDetail = (CustomUserDetails)SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        Future<String> task = jobService.doJob(customUserDetail.getUsername());
        jobService.setThread(task);
        String result = task.get();
    }
}

@Controller
public class StopJob {
    @Autowired
    private CustomEventPublisher customEventPublisher;

    @RequestMapping(value = "/stopJob.html", method= RequestMethod.GET)
    public void processUpload() throws Exception{
        if (SecurityContextHolder.getContext().getAuthentication().getPrincipal().equals("anonymousUser")){
            throw new AccessDeniedException("anonymous is not allow");
        }
        CustomUserDetails customUserDetail = (CustomUserDetails)SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        customEventPublisher.publishStopJob(customUserDetail.getUsername());
    }
}

@Component
public class JobService implements ApplicationListener<StopJobEvent> {
    private static final Logger log = Logger.getLogger(JobService.class);
    private final ExecutorService pool = Executors.newFixedThreadPool(10);

    private String username;
    private Future<String> thread;

    public void onApplicationEvent(StopJobEvent event) {
        log.info("job need stop for user: " + event.getUsername());
        if (event.getUsername()==username){
            thread.cancel(true);
        }
    }

    @Async
    public Future<String> doJob(String username) {
        //Запоминаем от чего имени был запущен Bean
        this.username = username;

        return pool.submit(new Callable<String>() {
            public String call() throws Exception {
                for(int i=0;i<100;i++){
                    Thread.sleep(1000);
                    log.info(i + ": some job doing");
                }
                return "job is done";
            }
        });
    }

    public void setThread(Future<String> thread){
        this.thread = thread;
    }
}

public class StopJobEvent extends ApplicationEvent {
    private String username;

    public StopJobEvent(String username, Object source) {
        super(source);
        this.username = username;
    }

    public String getUsername(){
        return this.username;
    }
}

    //Почему не Spring @Async ??
    private final ExecutorService pool = Executors.newFixedThreadPool(10);
    // Future это не Thread. Это контейнер в котором в будущем будет ссылка на результат выполнения задачи.
    private Future<String> thread;

        //Запоминаем от чего имени был запущен Bean
        // Может Session ID?
        this.username = username;

@Controller
public class StartJob {
    @Autowired
    private JobService jobService;

    @RequestMapping(value = "/startJob/{uuid}.html", method= RequestMethod.GET)
    public void createTable(@PathVariable UUID uuid){
        Future<String> future = jobService.doJob(uuid);
        jobService.setFuture(future);
    }
}

@Controller
public class StopJob {    
    @Autowired
    private StopJobHandler stopJobHandler;

    @RequestMapping(value = "/stopJob/{uuid}.html", method= RequestMethod.GET)
    public void cleanTable(@PathVariable UUID uuid){

        StopJobEvent event = new StopJobEvent(uuid, this);
        stopJobHandler.stopJob(event);
    }
}

@Component
public class JobService implements IStopJobListener {
    private static final Logger log = Logger.getLogger(JobService.class);

    private UUID uuidTable;
    private Future<String> thread;

    @Autowired
    private StopJobHandler stopJobHandler;

    public void onApplicationEvent(StopJobEvent event) {
        log.info("job need stop for user: " + event.getUuidTable());
        if (event.getUuidTable()==uuidTable){
            log.info("canceled for user: " + event.getUuidTable());
            thread.cancel(true);
            stopJobHandler.removeListener(this);
        }
        return;
    }

    public Future<String> doJob(UUID uuidTable) {
        stopJobHandler.addListener(this);
        this.uuidTable = uuidTable;

        try{
            for(int i=0;i<100;i++){
                Thread.sleep(1000);
                if (thread.isCancelled()){
                    break;
                }
                log.info(i + ": some job doing");
            }
        }catch (InterruptedException ex){

        }
        return new AsyncResult<>("job is done");
    }

    public void setFuture(Future<String> thread){
        this.thread = thread;
    }
}

public class StopJobHandler {
    List<IStopJobListener> listeners = new ArrayList<>();
    public void addListener(IStopJobListener listener) {
        listeners.add(listener);
    }

    public List<IStopJobListener> getListener() {
        return listeners;
    }

    public void removeListener(IStopJobListener listener) {
        listeners.remove(listener);
    }

    public void stopJob(StopJobEvent event){
        for( int i = 0; i < listeners.size(); i++ ) {
            listeners.get(i).onApplicationEvent(event);
        }
    }
}

public interface IStopJobListener {
    public void onApplicationEvent(StopJobEvent event);
}