CODEWITHSUNDEEP
javaconcurrency
parsecer
parsecer

Reputation: 5106

ExecutorService: get a list of submitted tasks and cancel all tasks without shutting down the executor

I have an ExecutorService that I submit tasks to:

private final ExecutorService CUSTOM_POOL = Executors
            .newCachedThreadPool();
private Queue<Future<?>> customTasksHandles;
private boolean started;

private Runnable task = new Runnable()  {
        @Override
        public void run()  {
            if (!started)  {return;}
            ...
            customTasksHandles.add(CUSTOM_POOL.submit(new CustomTask(customData)));
            ...
        }
}

I need to create public void stop() and public void start() functions. The stop() function would future.cancel() for every task that has been submitted to the executor, while the start() would start running the task Runnable again.

public void stop()  {
  ...
  Future customTasksHandle= customTasksHandles.poll();
        while (customTasksHandle!=null) {
            customTasksHandle.cancel(true);
            customTasksHandle=locationTasksHandles.poll();
        }
   ...
   started = false;
}

public void start()  {started = true;}

I tried to just CUSTOM_POOL.shutdown(), however it seems to make it impossible to submit new tasks later, after the start() is called. It seems that the only way is to loop over all submitted tasks and call .cancel() on each.

However, how do I get all submitted tasks without adding each task to a list/queue when submitting? Is there a better way to do it other than the way above? I was hoping for a List<Future> submittedTasks = CUSTOM_POOL.getAllSubmittedTasks() method of sorts, but there doesn't seem to be one. Interestingly, .shutdown() and invoke() methods do return List<Future>, but have side-effects.

Upvotes: 2

Views: 1130

Answers (2)

Ryuzaki L
Ryuzaki L

Reputation: 39978

You can achieve this by using Future, create start method which accepts Runnable and return Future

public Future<?> start(Runnable run) {
    return CUSTOM_POOL.submit(run);
}

You can save all these Future in a List or Map so that you can cancel which ever you need by using custom stop method

public void stop(Future<?> future) {
    future.cancel(true);
}

Example

public class TestMain {

private final ExecutorService CUSTOM_POOL = Executors
        .newCachedThreadPool();

public static void main(String[] args) {
  //custom logic

   }

public Future<?> start(Runnable run) {
    return CUSTOM_POOL.submit(run);
     }

public void stop(Future<?> future) {
    future.cancel(true);
     }
}

Future

Attempts to cancel execution of this task. This attempt will fail if the task has already completed, has already been cancelled, or could not be cancelled for some other reason. If successful, and this task has not started when cancel is called, this task should never run. If the task has already started, then the mayInterruptIfRunning parameter determines whether the thread executing this task should be interrupted in an attempt to stop the task.

Upvotes: 1

Javier Toja
Javier Toja

Reputation: 1762

As you can see here you could use the shutdownNow() method to stop and retrieve all the task that where waiting for execution. If what you want is just stop ("pause") the procesing of the task and the continue with it, you migth want to keep track yourself of the status of the taks and when you pause and unapuse the task you can resubmit the task returned by the mehtod shutdownNow() and the one that where executing in the instant of the stop. You should take into account that to stop the threads the pool may call thread interrupt so, if you are executing some sensible work you should take care of it properly. There is no pause and unpause for threads. check this

Upvotes: 1

Related Questions