Why Core Threads in Java ThreadPoolExecutor Never Die – A Deep Source Dive

Introduction

In a ByteDance interview question, candidates are asked how to guarantee that core threads in a thread pool are not reclaimed. The simple answer "they are not reclaimed by default" is insufficient; the interviewer expects an explanation of the underlying implementation.

1. Step One – The execute Method

The execute method is the entry point for submitting tasks to the pool.

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    int c = ctl.get();
    // Step 1: create core thread if current count < corePoolSize
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // Step 2: try to enqueue the task
    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);
    }
    // Step 3: try to create a non‑core thread
    else if (!addWorker(command, false))
        reject(command);
}

Key points:

Core thread creation: if the current worker count is less than corePoolSize, the pool attempts to create a core thread via addWorker(command, true).

Task queue: when core threads are saturated, tasks are placed into the work queue.

Non‑core thread creation: if the queue is full, the pool tries to create a non‑core thread with addWorker(command, false).

2. Step Two – The addWorker Method

addWorker

is the core routine for creating a thread.

private boolean addWorker(Runnable firstTask, boolean core) {
    // omitted part of the code …
    Worker w = null;
    try {
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            workers.add(w);
            t.start();
        }
    } finally {
        if (t == null)
            addWorkerFailed(w);
    }
    return t != null;
}

Key points:

Creating a Worker: the Worker object wraps the actual thread that will run tasks.

Starting the thread: t.start() launches the thread, which will later execute runWorker.

3. Step Three – The runWorker Method

runWorker

contains the main loop that fetches and runs tasks.

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask; // get initial task
    w.firstTask = null;
    w.unlock(); // allow interruption
    boolean completedAbruptly = true;
    try {
        while (task != null || (task = getTask()) != null) {
            w.lock();
            try {
                task.run();
            } finally {
                task = null;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

Key points:

Looping to obtain tasks: the worker repeatedly calls getTask() until no tasks are available.

Executing tasks: each task is run via task.run().

Handling thread exit: when the loop ends, processWorkerExit cleans up the worker.

4. Step Four – The getTask Method

getTask

is responsible for retrieving the next task from the queue and deciding whether the thread should exit.

4.1 Dead‑loop structure

private Runnable getTask() {
    boolean timedOut = false;
    for (;;) { // dead loop
        // omitted part of the code …
    }
}

The loop continuously attempts to fetch a task until a termination condition is met.

4.2 Checking pool state

int c = ctl.get();
int rs = runStateOf(c);
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
    decrementWorkerCount();
    return null; // thread exits
}

If the pool is shutting down or stopped and the queue is empty, the thread is reclaimed.

4.3 Determining timeout eligibility

int wc = workerCountOf(c);
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) {
    if (compareAndDecrementWorkerCount(c))
        return null; // thread exits
    continue;
}

The timed flag decides whether a core thread may time out; by default it is false, so core threads block indefinitely.

4.4 Fetching a task from the queue

try {
    Runnable r = timed ?
        workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
        workQueue.take();
    if (r != null)
        return r; // task obtained
    timedOut = true;
} catch (InterruptedException retry) {
    timedOut = false;
}

If timed is false (the default for core threads), workQueue.take() blocks forever, preventing core thread reclamation.

5. Summary

Core threads stay alive because:

By default allowCoreThreadTimeOut is false, so the timed flag in getTask is false and the thread blocks on workQueue.take() indefinitely.

Core threads are only reclaimed when the pool is shut down or when allowCoreThreadTimeOut is explicitly set to true, causing the thread to use workQueue.poll() with a timeout.

The dead‑loop in getTask continuously fetches tasks and reacts to pool state changes, ensuring that threads remain active as long as needed.