Java Language Executor, ExecutorService and Thread pools Use cases for different types of ExecutorService
Example
Executors returns different type of ThreadPools catering to specific need.
-
public static ExecutorService newSingleThreadExecutor()Creates an Executor that uses a single worker thread operating off an unbounded queue
There is a difference between
newFixedThreadPool(1)andnewSingleThreadExecutor()as the java doc says for the latter:Unlike the otherwise equivalent newFixedThreadPool(1) the returned executor is guaranteed not to be reconfigurable to use additional threads.
Which means that a
newFixedThreadPoolcan be reconfigured later in the program by:((ThreadPoolExecutor) fixedThreadPool).setMaximumPoolSize(10)This is not possible fornewSingleThreadExecutorUse cases:
- You want to execute the submitted tasks in a sequence.
- You need only one Thread to handle all your request
Cons:
- Unbounded queue is harmful
-
public static ExecutorService newFixedThreadPool(int nThreads)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, they will wait in the queue until a thread is available
Use cases:
- Effective use of available cores. Configure
nThreadsasRuntime.getRuntime().availableProcessors() - When you decide that number of thread should not exceed a number in the thread pool
Cons:
- Unbounded queue is harmful.
- Effective use of available cores. Configure
-
public static ExecutorService newCachedThreadPool()Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available
Use cases:
- For short-lived asynchronous tasks
Cons:
- Unbounded queue is harmful.
- Each new task will create a new thread if all existing threads are busy. If the task is taking long duration, more number of threads will be created,which will degrade the performance of the system. Alternative in this case:
newFixedThreadPool
-
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)Creates a thread pool that can schedule commands to run after a given delay, or to execute periodically.
Use cases:
- Handling recurring events with delays, which will happen in future at certain interval of times
Cons:
- Unbounded queue is harmful.
5.
public static ExecutorService newWorkStealingPool()Creates a work-stealing thread pool using all available processors as its target parallelism level
Use cases:
- For divide and conquer type of problems.
- Effective use of idle threads. Idle threads steals tasks from busy threads.
Cons:
- Unbounded queue size is harmful.
You can see one common drawbacks in all these ExecutorService : unbounded queue. This will be addressed with ThreadPoolExecutor
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,
RejectedExecutionHandler handler)
With ThreadPoolExecutor, you can
- Control Thread pool size dynamically
- Set the capacity for
BlockingQueue - Define
RejectionExecutionHanderwhen queue is full CustomThreadFactoryto add some additional functionality during Thread creation(public Thread newThread(Runnable r)
