Understanding Java Thread Pools: Concepts, Benefits, and Usage

After a series of introductory articles on multithreading, this tutorial focuses on Java thread pools, a technique that pools reusable threads to reduce resource consumption and improve performance.

Thread Pool Overview

A thread pool is a pooling technology similar to database or HTTP connection pools. It maintains a set of threads so that tasks can obtain a thread from the pool instead of creating a new one each time, thereby saving the overhead of thread creation and destruction.

In Java, thread pools are implemented in the java.util.concurrent package, primarily via the ThreadPoolExecutor class.

Benefits of Using a Thread Pool

Reduces resource consumption by reusing existing threads.

Improves response speed because tasks can start immediately without waiting for thread creation.

Provides extensibility, allowing features such as scheduled or delayed execution.

Implementation Details

The ThreadPoolExecutor constructor has seven parameters:

public ThreadPoolExecutor(int corePoolSize,
                           int maximumPoolSize,
                           long keepAliveTime,
                           TimeUnit unit,
                           BlockingQueue<Runnable> workQueue,
                           ThreadFactory threadFactory,
                           RejectedExecutionHandler handler) {
    ...
}

corePoolSize : number of core threads that stay alive even when idle.

maximumPoolSize : maximum number of threads allowed.

keepAliveTime : time that excess idle threads wait before termination.

unit : time unit for keepAliveTime.

workQueue : a BlockingQueue that holds tasks before execution.

threadFactory : factory for creating new threads.

handler : rejection policy used when the pool is saturated.

Common Built‑In Thread Pools

newCachedThreadPool

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                60L, TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>());
    }

Core size 0, unlimited maximum, 60‑second idle timeout, and a synchronous queue. Suitable for many short‑lived asynchronous tasks.

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>());
    }

Fixed number of threads; excess tasks wait in an unbounded queue.

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService(
                new ThreadPoolExecutor(1, 1,
                        0L, TimeUnit.MILLISECONDS,
                        new LinkedBlockingQueue<Runnable>()));
    }

Exactly one worker thread; tasks are executed sequentially.

Rejection Policies

The ThreadPoolExecutor provides four built‑in RejectedExecutionHandler implementations: AbortPolicy: throws RejectedExecutionException. DiscardPolicy: silently discards the task. DiscardOldestPolicy: discards the oldest queued task and retries the new one. CallerRunsPolicy: runs the task in the calling thread.

All three built‑in pool factories use the default AbortPolicy.

Conclusion

Using a thread pool in Java essentially means configuring a ThreadPoolExecutor with appropriate parameters and, optionally, a custom rejection handler. Proper selection of workQueue and handler can further tune performance and reliability.

The full source code and additional examples are available on the author's GitHub repository.