Understanding ThreadPoolExecutor: Parameters, Work Mechanism, and Custom ThreadFactory

ThreadPoolExecutor is the most commonly used executor for running Runnable tasks in Java, often created directly via new ThreadPoolExecutor or through factory methods such as Executors.newFixedThreadPool . Alibaba's BB guidelines discourage using Executors to avoid missing configuration parameters that could lead to resource exhaustion.

The constructor signature is:

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

Key parameters:

corePoolSize : number of core (permanent) threads.

maximumPoolSize : maximum number of threads (core + temporary).

keepAliveTime & unit : idle time before terminating temporary threads.

workQueue : queue that holds pending tasks.

threadFactory : creates new threads, allowing custom naming or other properties.

handler : policy for handling rejected tasks when the pool is saturated.

An analogy compares the pool to a company: core threads are permanent employees, the work queue is a task backlog, and temporary threads are hired when the backlog exceeds capacity; the rejection handler acts as the HR decision when no more workers can be added.

Execution proceeds in three steps:

step1

If the current thread count is less than corePoolSize , a new core thread is created via addWorker and the task is executed.

step2

If the core pool is full, the task is offered to workQueue . Idle threads will later retrieve tasks from the queue.

step3

If the queue is full and the total thread count is still below maximumPoolSize , a temporary thread is created; it lives for keepAliveTime before termination. If the pool cannot grow, the task is rejected using the provided handler .

The actual thread creation is delegated to a ThreadFactory . A custom implementation can enforce naming conventions:

private static ThreadFactory threadFactory = new ThreadFactory() {
    private AtomicInteger no = new AtomicInteger(0);
    @Override
    public Thread newThread(Runnable r) {
        return new Thread(r, "my-thread-" + no.incrementAndGet());
    }
};

Finally, the execute method of ThreadPoolExecutor orchestrates these steps, checking the pool state, offering tasks to the queue, and invoking addWorker as needed, with rejection handling as the last resort.

Understanding these mechanisms reveals the complexity of ensuring thread‑safety and efficient resource utilization, and motivates building a custom thread pool for deeper insight.