Understanding Java ThreadPoolExecutor: Creation, Parameters, and Execution Flow

As CPU core counts increase, multithreading becomes indispensable for server‑side development, and thread pools are used to avoid the overhead of frequent thread creation and destruction.

1. Thread Pool Creation

The most complete constructor of ThreadPoolExecutor includes the following parameters:

corePoolSize : number of core threads that stay alive even when there are no tasks.

maximumPoolSize : maximum number of threads that can be created.

keepAliveTime : time that excess threads (beyond corePoolSize) wait for new tasks before terminating.

unit : time unit for keepAliveTime (e.g., TimeUnit.SECONDS).

workQueue : a blocking queue that holds submitted tasks.

threadFactory : factory that creates new threads, typically assigning names like pool-1-thread-3.

handler : rejection policy invoked when the pool and queue are saturated.

2. Thread Pool Execution Process

When a task is submitted, the executor follows these steps:

If the current worker count is less than corePoolSize, a new thread is created via addWorker to execute the task.

Otherwise the task is placed into workQueue.

If the queue is full and the worker count is below maximumPoolSize, another thread is created.

If creation fails, the handler is invoked to reject the task.

2.1 Executor Method Logic

The executor first checks the active thread count against corePoolSize, then decides whether to add a worker or enqueue the task, and finally handles rejection if necessary.

2.2 addWorker Implementation

When creating a non‑core thread ( core = false), addWorker verifies that the current thread count does not exceed maximumPoolSize. If it does, the method returns false, causing the rejection path.

The method then creates a Worker object, instantiates a Thread via the provided threadFactory, and starts the thread.

2.3 Worker Run Logic

The Worker implements Runnable; its run method invokes runWorker(this), which repeatedly calls getTask() to fetch work from the queue.

2.4 runWorker Details

Inside runWorker, a loop continuously obtains tasks with getTask() and executes them. The loop exits only when getTask() returns null, meaning the thread should terminate.

2.5 getTask Implementation

If allowCoreThreadTimeOut is false (default), the method checks whether the current worker count exceeds corePoolSize. If it does, it attempts to poll the queue with a timeout of keepAliveTime. A timeout returning null ends the loop and the thread exits. If the worker count is less than or equal to corePoolSize, the method blocks on workQueue.take() waiting for new tasks.

These steps together illustrate how ThreadPoolExecutor manages thread lifecycles, task queuing, and rejection handling in Java.