Comprehensive Guide to Java Thread Pools: Concepts, Common Interview Questions, and Practical Usage

Mastering thread pools is a fundamental requirement for backend developers, and interviewers often ask about them. This article collects classic interview questions and uses them as a basis to explain the concepts and practical usage of Java thread pools.

Classic Interview Questions

Explain Java thread pools and the purpose of each parameter.

What exceptions need to be considered when submitting a new task?

What kinds of work queues do thread pools have?

Will using an unbounded queue cause memory to explode?

Describe common thread pool types and their use cases.

Thread Pool Concept

A thread pool is a pool that manages threads, reducing the overhead of creating and destroying thread objects, improving response speed, and allowing thread reuse.

Creating a Thread Pool

Thread pools can be created via ThreadPoolExecutor. Its constructor signature is:

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

Key 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 : creates new threads, allowing custom naming.

handler : saturation policy (four types).

Task Execution Flow (execute())

The execution process follows these steps:

If the number of live core threads is less than corePoolSize, a core thread is created to handle the task.

If core threads are full, the task is placed into workQueue for later execution.

If the queue is full and the total thread count is less than maximumPoolSize, a non‑core thread is created.

If the pool has reached maximumPoolSize, the task is handled by the rejection policy.

Four Rejection Policies

AbortPolicy – throws a RejectedExecutionException (default).

DiscardPolicy – silently discards the task.

DiscardOldestPolicy – discards the oldest task in the queue and retries submission.

CallerRunsPolicy – runs the task in the calling thread.

Analogy

Core threads = formal employees.

Non‑core threads = outsourced workers.

Work queue = demand pool.

Submitting a task = raising a demand.

Thread Pool Exception Handling

When a task throws a RuntimeException, the pool may catch it or replace the thread, making the exception invisible. Common handling strategies:

Wrap task code with try/catch.

Use Future.get() to retrieve and handle exceptions.

Set an UncaughtExceptionHandler on worker threads.

Override ThreadPoolExecutor.afterExecute() to process exceptions.

Example of using Future.get():

ExecutorService threadPool = Executors.newFixedThreadPool(5);
for (int i = 0; i < 5; i++) {
    threadPool.submit(() -> {
        System.out.println("current thread name" + Thread.currentThread().getName());
        Object object = null;
        System.out.print("result## " + object.toString());
    });
}

Example of setting an UncaughtExceptionHandler:

ExecutorService threadPool = Executors.newFixedThreadPool(1, r -> {
    Thread t = new Thread(r);
    t.setUncaughtExceptionHandler((t1, e) -> {
        System.out.println(t1.getName() + "线程抛出的异常" + e);
    });
    return t;
});
threadPool.execute(() -> {
    Object object = null;
    System.out.print("result## " + object.toString());
});

Example of overriding afterExecute:

class ExtendedExecutor extends ThreadPoolExecutor {
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        if (t == null && r instanceof Future<?>) {
            try {
                Object result = ((Future<?>) r).get();
            } catch (CancellationException ce) {
                t = ce;
            } catch (ExecutionException ee) {
                t = ee.getCause();
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
            }
        }
        if (t != null) System.out.println(t);
    }
}

Thread Pool Work Queues

ArrayBlockingQueue – bounded array‑based queue (FIFO).

LinkedBlockingQueue – optionally bounded linked list queue (FIFO), used by newFixedThreadPool.

DelayQueue – delayed execution queue, used by newScheduledThreadPool.

PriorityBlockingQueue – unbounded priority queue.

SynchronousQueue – hand‑off queue with no storage, used by newCachedThreadPool.

Common Thread Pool Types

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(), threadFactory);
}

Characteristics: core and max threads are equal, no keep‑alive time, uses an unbounded LinkedBlockingQueue. Suitable for CPU‑intensive long‑running tasks. Using an unbounded queue can cause memory spikes if tasks accumulate faster than they finish.

newCachedThreadPool

public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>(), threadFactory);
}

Characteristics: core size 0, max size unlimited, uses SynchronousQueue, idle threads die after 60 seconds. Ideal for many short‑lived tasks but can create many threads under heavy load.

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
    return new FinalizableDelegatedExecutorService(
        new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,
                               new LinkedBlockingQueue<Runnable>(), threadFactory));
}

Characteristics: a single worker thread with a LinkedBlockingQueue. Guarantees sequential execution of tasks.

newScheduledThreadPool

public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue());
}

Features: supports scheduleAtFixedRate and scheduleWithFixedDelay for periodic tasks. Uses a delayed work queue.

Thread Pool States

The pool can be in one of five states: RUNNING, SHUTDOWN, STOP, TIDYING, TERMINATED. Transitions occur via shutdown(), shutdownNow(), and internal completion of tasks. A state diagram is provided in the original article.

End of article.