Understanding Java Thread Pools: Benefits, Detailed Parameters, and Singleton Implementation

1. Benefits of Thread Pools

Thread pools reuse threads to avoid the high cost of creating and destroying threads, which reduces memory consumption and improves execution speed.

They allow control over the number of concurrent threads, preventing CPU contention and resource blockage.

Thread pools also provide management features such as scheduled execution, fixed-size, and single-thread execution.

2. Detailed Explanation of Thread Pools

The core class is ThreadPoolExecutor , which has seven parameters: corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, and handler. The most commonly used parameters are corePoolSize, maximumPoolSize, keepAliveTime, unit, and workQueue.

corePoolSize is the number of core threads, maximumPoolSize is the maximum number of threads, keepAliveTime is the idle timeout for non‑core threads (or core threads if allowed), unit specifies the time unit, and workQueue holds tasks waiting for execution.

The execution flow is:

If the current pool size is less than corePoolSize, a core thread is created.

If the pool size is at least corePoolSize and the workQueue is not full, the task is queued.

If the queue is full and the pool size is below maximumPoolSize, a non‑core thread is created.

If the queue is full and the pool size has reached maximumPoolSize, the rejection handler throws RejectedExecutionException .

Four common thread‑pool types are FixedThreadPool, SingleThreadPool, CachedThreadPool, and ScheduledThreadPool, each with characteristic parameter settings.

3. Thread Pool Singleton

To avoid creating multiple thread‑pool instances, a singleton pattern can be applied. The example defines a private constructor and a static getThreadPool() method that creates a single ThreadPool instance based on the number of CPU cores.

Sample code:

private ThreadPool(int corepoolsize, int maximumpoolsize, long keepalivetime) { ... }

public void executor(Runnable runnable) { ... }

public static ThreadPool getThreadPool() { ... }

This design ensures that the whole application shares one thread pool, reducing resource waste and simplifying management.