Why Direct Thread Creation Fails and How Java Thread Pools Boost Performance

Thread Pool Overview

Creating and destroying threads is expensive: each new Thread requires a native OS thread, which consumes memory and CPU time. In high‑concurrency scenarios frequent thread creation can lead to 100% CPU usage, out‑of‑memory errors, or crashes. A thread pool mitigates these problems by reusing a fixed set of worker threads and managing their lifecycle.

Since JDK 1.5 Java provides the Executor framework. The most important classes are: Executor – a simple command‑execution interface. ExecutorService – adds lifecycle management (shutdown, awaitTermination). ThreadPoolExecutor – the core implementation that executes Runnable tasks using a pool of threads. ScheduledThreadPoolExecutor – extends ThreadPoolExecutor with delayed and periodic execution. Executors – a utility class with factory methods (e.g., newFixedThreadPool), which are convenient but hide important tuning parameters and are therefore discouraged in production.

Advantages of Using a Thread Pool

Reuses existing threads, eliminating the overhead of repeatedly creating and destroying native threads.

Limits the maximum number of concurrent threads, preventing resource contention and out‑of‑memory conditions.

Supports scheduled and periodic task execution via ScheduledThreadPoolExecutor.

Provides built‑in metrics (active count, completed task count, queue size) for monitoring.

ThreadPoolExecutor Constructor

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

Parameter Details

corePoolSize – Number of core threads that are kept alive even when idle. These threads are created eagerly and never terminated unless allowCoreThreadTimeOut is enabled.

maximumPoolSize – Upper bound of total threads (core + non‑core). The pool will never create more than this number.

keepAliveTime – Time that excess (non‑core) threads may remain idle before being terminated.

unit – Time unit for keepAliveTime (e.g., TimeUnit.SECONDS).

workQueue – A BlockingQueue<Runnable> that holds tasks waiting for execution. Common choices are ArrayBlockingQueue, LinkedBlockingQueue, and SynchronousQueue.

threadFactory – Factory that creates new threads. The default factory assigns a name, sets non‑daemon status, and uses normal priority.

rejectHandler – Strategy invoked when the queue is full and the pool cannot accept new tasks.

Interaction of corePoolSize, maximumPoolSize and workQueue

If the current pool size is less than corePoolSize, a new thread is created for each incoming task, regardless of the queue state.

If the pool size is between corePoolSize and maximumPoolSize, new threads are created only when workQueue is full; otherwise tasks are queued.

When the pool size reaches maximumPoolSize and the queue is also full, the rejectHandler determines how to handle additional tasks.

Rejection Policies

AbortPolicy – Throws a RejectedExecutionException (default).

CallerRunsPolicy – Executes the rejected task in the thread that invoked execute.

DiscardOldestPolicy – Removes the oldest task in the queue and retries execution of the new task.

DiscardPolicy – Silently discards the new task.

Summary

A properly configured ThreadPoolExecutor eliminates the inefficiencies of raw Thread creation, provides controlled concurrency, supports delayed and periodic execution, and offers flexible rejection handling. These features make it essential for building high‑performance Java backend services.