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

Thread pools are a core Java concurrency tool that reduce the overhead of creating and destroying threads, improve execution speed, and allow control over the number of concurrent threads to avoid CPU contention.

Benefits of thread pools include:

Reuse of threads, minimizing creation/destruction costs.

Control of concurrency to prevent resource saturation.

Management features such as scheduling, fixed or dynamic thread counts, and task queuing.

The article also clarifies the difference between concurrency (multiple tasks progressing over time but not necessarily simultaneously) and parallelism (tasks truly running at the same time), using simple analogies.

ThreadPoolExecutor constructor (seven parameters):

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

The most frequently used parameters are corePoolSize, maximumPoolSize, keepAliveTime, unit, and workQueue. Their meanings are: corePoolSize: number of core threads kept alive. maximumPoolSize: maximum number of threads. keepAliveTime: idle time before non‑core threads are terminated (also applies to core threads if allowCoreThreadTimeOut is true). unit: time unit for keepAliveTime. workQueue: queue that holds tasks awaiting execution. threadFactory: creates new threads (default is usually sufficient). handler: rejection policy when the pool cannot accept new tasks (default throws RejectedExecutionException).

Typical usage focuses on corePoolSize, maximumPoolSize, and workQueue. The relationship maximumPoolSize = corePoolSize + nonCorePoolSize determines how the pool expands under load, illustrated with a barbecue‑shop analogy.

Common thread‑pool types : FixedThreadPool: fixed number of threads (core = max, keepAlive = 0). SingleThreadPool: a single‑thread pool (core = max = 1). CachedThreadPool: unbounded pool (core = 0, max = Integer.MAX_VALUE). ScheduledThreadPool: supports delayed and periodic task execution.

The article then introduces the Singleton design pattern and explains why a thread pool is often implemented as a singleton so that the entire application shares a single pool instance.

Singleton pattern ensures only one instance of a class exists and provides a global access point.

Example code for a singleton ThreadPool using a FixedThreadPool:

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

public void executor(Runnable runnable) {
    if (runnable == null) {
        return;
    }
    if (mexecutor == null) {
        mexecutor = new ThreadPoolExecutor(corepoolsize, maximumpoolsize, keepalivetime,
            TimeUnit.MILLISECONDS, new LinkedBlockingDeque<>(),
            Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
    }
    mexecutor.execute(runnable);
}

Singleton accessor:

public static ThreadPool getThreadPool() {
    if (mThreadPool == null) {
        synchronized (ThreadManager.class) {
            if (mThreadPool == null) {
                int cpuNum = Runtime.getRuntime().availableProcessors();
                int threadNum = cpuNum * 2 + 1; // reasonable concurrency based on CPU count
                mThreadPool = new ThreadPool(threadNum, threadNum, 0L);
            }
        }
    }
    return mThreadPool;
}

The article concludes with a friendly note encouraging feedback and sharing.