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
The purpose of having separate dedicated threadpools is so that an activity doesn’t get starved for threads because other activities took all the threads. If some service has its own threadpool then it is assured of having a certain number of threads at its disposal and it’s not as sensitive to demands made by other … Read more
When you submit a task to the executor, it returns you a FutureTask instance. FutureTask.get() will re-throw any exception thrown by the task as an ExecutorException. So when you iterate through the List<Future> and call get on each, catch ExecutorException and invoke an orderly shutdown.
From this blog post: Take this example. Starting thread pool size is 1, core pool size is 5, max pool size is 10 and the queue is 100. As requests come in, threads will be created up to 5 and then tasks will be added to the queue until it reaches 100. When the queue … Read more
If you are interested in knowing when a certain task completes, or a certain batch of tasks, you may use ExecutorService.submit(Runnable). Invoking this method returns a Future object which may be placed into a Collection which your main thread will then iterate over calling Future.get() for each one. This will cause your main thread to … Read more
The ThreadPoolExecutor has the following several key behaviors, and your problems can be explained by these behaviors. When tasks are submitted, If the thread pool has not reached the core size, it creates new threads. If the core size has been reached and there is no idle threads, it queues tasks. If the core size … Read more
ExecutorService ExecutorService executor=Executors.newFixedThreadPool(50); It is simple and easy to use. It hides low level details of ThreadPoolExecutor. Prefer this one when number of Callable/Runnable tasks are small in number and piling of tasks in unbounded queue does not increase memory & degrade the performance of the system. If you have CPU/Memory constraints, use ThreadPoolExecutor with … Read more
How can I work around this limitation in ThreadPoolExecutor where the queue needs to be bounded and full before more threads will be started. I believe I have finally found a somewhat elegant (maybe a little hacky) solution to this limitation with ThreadPoolExecutor. It involves extending LinkedBlockingQueue to have it return false for queue.offer(…) when … Read more
I think the docs explain the difference and usage of these two functions pretty well: newFixedThreadPool Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue. At any point, at most nThreads threads will be active processing tasks. If additional tasks are submitted when all threads are active, … Read more
WARNING: It should be noted that this solution will block the calling thread. If you want to process exceptions thrown by the task, then it is generally better to use Callable rather than Runnable. Callable.call() is permitted to throw checked exceptions, and these get propagated back to the calling thread: Callable task = … Future … Read more