Understanding Java ThreadPoolExecutor: Creation, Configuration, and Execution Logic

Preface

In everyday development we often write single‑threaded code without considering concurrency, which can lead to excessive requests and unresponsive applications. Thread pools address this by reusing a fixed set of threads to handle tasks efficiently.

What is a Thread Pool?

A thread pool is a software design pattern that maintains a set of threads ready to execute tasks, improving performance and avoiding the overhead of creating and destroying threads for short‑lived tasks.

Problems Solved by a Thread Pool

Each thread goes through a lifecycle from New → Runnable → Running → Terminated. By reusing threads, a pool eliminates the cost of repeatedly creating and destroying threads, saving system resources and increasing response speed.

Using a Thread Pool

Creating a ThreadPoolExecutor

The constructor ThreadPoolExecutor requires seven parameters:

corePoolSize – maximum number of core threads

maximumPoolSize – maximum number of threads

keepAliveTime – idle time for non‑core threads

unit – time unit for keepAliveTime

workQueue – the blocking queue that holds tasks

threadFactory – factory for creating new threads (e.g., naming)

handler – rejection policy

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

Common Blocking Queues

ArrayBlockingQueue

A bounded queue backed by an array.

LinkedBlockingQueue

A queue backed by a linked list; if no capacity is specified it defaults to Integer.MAX_VALUE.

Thread Factory

Alibaba Java Development Manual requires naming threads. Using ThreadFactoryBuilder simplifies this:

ThreadFactory threadFactory = ThreadFactoryBuilder.create()
    .setNamePrefix("myThread-")
    .build();

Rejection Policies

When the number of active threads exceeds maximumPoolSize, the pool applies one of four policies:

AbortPolicy (default) – throws RejectedExecutionException CallerRunsPolicy – the calling thread runs the task

DiscardOldestPolicy – discards the oldest queued task and retries

DiscardPolicy – silently discards the task

Thread Pool Execution Logic

// Create thread factory
ThreadFactory threadFactory = ThreadFactoryBuilder.create()
    .setNamePrefix("myThread-")
    .build();
// Create thread pool
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
    5, 10, 10, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(100),
    threadFactory,
    new ThreadPoolExecutor.AbortPolicy());

execute() Method

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

public void execute(Runnable command) {
    if (command == null) throw new NullPointerException();
    int c = ctl.get();
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        if (!isRunning(recheck) && remove(command))
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    } else if (!addWorker(command, false))
        reject(command);
}

Execution Flow

End of article.