Using a ExecutorCompletionService.poll/take, you are receiving the Futures as they finish, in completion order (more or less). Using ExecutorService.invokeAll, you do not have this power; you either block until are all completed, or you specify a timeout after which the incomplete are cancelled. static class SleepingCallable implements Callable<String> { final String name; final long period; … Read more
Have a look at below API in ThreadPoolExecutor public void setCorePoolSize(int corePoolSize) Sets the core number of threads. This overrides any value set in the constructor. If the new value is smaller than the current value, excess existing threads will be terminated when they next become idle. If larger, new threads will, if needed, be … Read more
Shutdown hook is not a good approach in Tomcat because: it will close the pool too late (on shutdown), Tomcat will already warn you about not closed resources you actually want to shutdown that pool when application is undeployed so that redeployment works (otherwise each application will create new pool and they will all be … Read more
I used to work on an app with long running threads. We do this at shutdown, BlockingQueue<Runnable> queue = threadPool.getQueue(); List<Runnable> list = new ArrayList<Runnable>(); int tasks = queue.drainTo(list); The list is saved to a file. On startup, the list is added back to the pool so we don’t lose any jobs.
I write own Executor that warrants task ordering for tasks with same key. It uses map of queues for order tasks with same key. Each keyed task execute next task with the same key. This solution don’t handle RejectedExecutionException or other exceptions from delegated Executor! So delegated Executor should be “unlimited”. import java.util.HashMap; import java.util.LinkedList; … Read more
I later hit breakpoints within the Callable procedure, as if the Future cancel() had no effect. Future.cancel(true) removes a job that is in the queue and not yet running but if the job is already running it does the equivalent of Thread.interrupt() on the thread running the job. This sets the interrupt bit on the … Read more
Just because you call cancel() on Future doesn’t mean that the task will stop automatically. You have to do some work within the task to make sure that it will stop: Use cancel(true) so that an interrupt is sent to the task. Handle InterruptedException. If a function in your task throws an InterruptedException, make sure … Read more
Option 1 : You are submitting the tasks to ExecutorService and you are not waiting for the completion of all tasks, which have been submitted to ExecutorService Option 2 : You are waiting for completion of all tasks, which have been submitted to ExecutorService. What should be the preferred way? Depending on application requirement, either … Read more
To answer my own question, I found an example of a PausableThreadPoolExecutor in the javadocs of ThreadPoolExecutor itself. Here is my version using Guava’s Monitors: import com.google.common.util.concurrent.Monitor; import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.ThreadFactory; public class PausableExecutor extends ScheduledThreadPoolExecutor { private boolean isPaused; private final Monitor monitor = new Monitor(); private final Monitor.Guard paused = new Monitor.Guard(monitor) { … Read more
While the question and the sample code do not correlate, I’ll try clarifying both. The advantage of ExecutorService over haphazardly spawning threads is that it behaves predictably and avoids the overhead of thread creation, which is relatively big on the JVM (it needs to reserve memory for each thread, for example). By predictability, I mean … Read more