Understanding of java thread pool source code

Thread Pool

New threads and switching threads are too expensive, and using thread pools can save system resources.

ThreadPoolExecutor is a key class of thread pools.

This class contains a number of multithreaded and concurrent processing tools, including ReentrantLock, AtomicInteger, AQS, CAS, BlockingQueue, and so on.

Main Processes

execute() –> addWorker() –>runWorker() -> getTask()

Important parameters and variables

  • Control state variable ctl:
    ctl is an AtomicInteger atomic operation class that ensures thread safety.

The ctl variable is defined as follows:

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

private static int ctlOf(int rs, int wc) { return rs | wc; }

Explain in detail as follows:

The main pool control state, ctl, is an atomic integer packing
two conceptual fields
workerCount, indicating the effective number of threads
runState,    indicating whether running, shutting down etc

By running ctl, you get two important variables, workerCount (the number of worker threads) and runState (the running state of the thread pool).

  • Thread pool running state runState:

runState is represented by several integer constants RUNNING, SHUTDOWN, STOP, TIDYING, TERMINATED.

The runState provides the main lifecycle control, taking on values:

RUNNING:  Accept new tasks and process queued tasks
SHUTDOWN: Don't accept new tasks, but process queued tasks
STOP:     Don't accept new tasks, don't process queued tasks,
		  and interrupt in-progress tasks
TIDYING:  All tasks have terminated, workerCount is zero,
		  the thread transitioning to state TIDYING
		  will run the terminated() hook method
TERMINATED: terminated() has completed

Internal class Worker:

Worker class, inherits AQS, and implements Runnable.

This class maintains the state of interception control for threads running tasks and simplifies the process of acquiring and releasing locks on each Task.

There is a threaded thread variable inside the Worker class, and the threaded object is created when the Worker class is instantiated.

What is the difference between a Worker class and a Task?

Task only implements the Runnable interface, while the Worker class inherits AQS, and Worker also helps acquire and release locks.

The worker is a thread in the thread pool, and Task is run nable, but it does not really execute. It is only called by the worker, and only the worker actually opens and executes.

     * Class Worker mainly maintains interrupt control state for
     * threads running tasks, along with other minor bookkeeping.
     * This class opportunistically extends AbstractQueuedSynchronizer
     * to simplify acquiring and releasing a lock surrounding each
     * task execution.  This protects against interrupts that are
     * intended to wake up a worker thread waiting for a task from
     * instead interrupting a task being run.  We implement a simple
     * non-reentrant mutual exclusion lock rather than use
     * ReentrantLock because we do not want worker tasks to be able to
     * reacquire the lock when they invoke pool control methods like
     * setCorePoolSize.  Additionally, to suppress interrupts until
     * the thread actually starts running tasks, we initialize lock
     * state to a negative value, and clear it upon start (in
     * runWorker).
    private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
         * This class will never be serialized, but we provide a
         * serialVersionUID to suppress a javac warning.
        private static final long serialVersionUID = 6138294804551838833L;

        /** Thread this worker is running in.  Null if factory fails. */
        //Very important thread variables
        final Thread thread;
        /** Initial task to run.  Possibly null. */
        Runnable firstTask;
        /** Per-thread task counter */
        volatile long completedTasks;

         * Creates with given first task and thread from ThreadFactory.
         * @param firstTask the first task (null if none)
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            //When the Worker class is instantiated, a thread ed object is also created.
            this.thread = getThreadFactory().newThread(this);

        /** Delegates main run loop to outer runWorker  */
        public void run() {

        // Lock methods
        // The value 0 represents the unlocked state.
        // The value 1 represents the locked state.

        protected boolean isHeldExclusively() {
            return getState() != 0;

        protected boolean tryAcquire(int unused) {
            if (compareAndSetState(0, 1)) {
                return true;
            return false;

        protected boolean tryRelease(int unused) {
            return true;

        public void lock()        { acquire(1); }
        public boolean tryLock()  { return tryAcquire(1); }
        public void unlock()      { release(1); }
        public boolean isLocked() { return isHeldExclusively(); }

        void interruptIfStarted() {
            Thread t;
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                } catch (SecurityException ignore) {


execute() is used to execute a task, and the parameter command is the task to be executed.

Depending on the running state of the thread pool and the number of threads in the thread pool, it is decided whether to execute addWorker() or reject the policy ().

If the number of threads is less than the number of core threads, a worker thread task is created and executed.

If the number of threads is greater than the number of core threads, tasks will only be added to the work queue if the thread pool is in the running state.

If the number of threads is greater than the maximum number of threads, or if the thread pool is in a non-running state, a denial policy is executed.

Resolution of parameters such as number of core threads, maximum threads, rejection policy, etc. can be found in: https://www.cnblogs.com/expiator/p/9053754.html

     * Executes the given task sometime in the future.  The task
     * may execute in a new thread or in an existing pooled thread.
     * If the task cannot be submitted for execution, either because this
     * executor has been shutdown or because its capacity has been reached,
     * the task is handled by the current {@code RejectedExecutionHandler}.
     * @param command the task to execute
     * @throws RejectedExecutionException at discretion of
     *         {@code RejectedExecutionHandler}, if the task
     *         cannot be accepted for execution
     * @throws NullPointerException if {@code command} is null
    public void execute(Runnable command) {
    //execute() parameter command is the task to be executed
        if (command == null)
            throw new NullPointerException();
         * Proceed in 3 steps:
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
        int c = ctl.get();
        //If the number of worker threads is less than the number of core threads, create worker thread tasks and execute them
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
            c = ctl.get();
        //add() and offer() in the blocked queue BlockingQueue are used to add an element to the queue.
        //When the capacity is full, the add() method throws an IllegalStateException exception, and the offer() method only returns false.
        //If the number of worker threads is greater than the number of core threads, tasks will only be added to the work queue if the thread pool is in the running state.
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        else if (!addWorker(command, false))


The Boolean parameter core of the addWorker() method depends on the bounding range of the workerCount (that is, the number of workers).

This method instantiates the Worker object worker, and the thread variable threads inside the worker get the reentrant lock ReentrantLock.

Thread security is guaranteed through ReentrantLock locking.

The new worker object is then added to the HashSet collection workers and the lock is released when the operation is complete.

Finally, the thread is opened, and the run() method inside the worker object is automatically executed, and the run() method is executed inside the runWorker().

     * Checks if a new worker can be added with respect to current
     * pool state and the given bound (either core or maximum). If so,
     * the worker count is adjusted accordingly, and, if possible, a
     * new worker is created and started, running firstTask as its
     * first task. This method returns false if the pool is stopped or
     * eligible to shut down. It also returns false if the thread
     * factory fails to create a thread when asked.  If the thread
     * creation fails, either due to the thread factory returning
     * null, or due to an exception (typically OutOfMemoryError in
     * Thread.start()), we roll back cleanly.
     * @param firstTask the task the new thread should run first (or
     * null if none). Workers are created with an initial first task
     * (in method execute()) to bypass queuing when there are fewer
     * than corePoolSize threads (in which case we always start one),
     * or when the queue is full (in which case we must bypass queue).
     * Initially idle threads are usually created via
     * prestartCoreThread or to replace other dying workers.
     * @param core if true use corePoolSize as bound, else
     * maximumPoolSize. (A boolean indicator is used here rather than a
     * value to ensure reads of fresh values after checking other pool
     * state).
     * @return true if successful
    private boolean addWorker(Runnable firstTask, boolean core) {
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                //The Boolean parameter core of the method, which determines the bounding range of workerCount (that is, the number of workers)
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                //The plus 1 operation is performed through the CAS mechanism.See below for details.   
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            //Instantiate the Worker object, the thread variable threads inside the Worker object get the reentrant lock ReentrantLock, and release the lock when the operation is complete to ensure thread safety.
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        //Add the worker object to the HashSet <Worker>object workers.The size() of this HashSet collection workers is actually the size of the thread pool.    
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                } finally {
                if (workerAdded) {
                    //Opening a thread automatically executes the run() method inside the Worker object, and the run() method executes the runWorker().
                    workerStarted = true;
        } finally {
            if (! workerStarted)
        return workerStarted;
  • AtomicInteger and CAS:

Operating basic type variables in multiple threads makes using AtomicInteger a good choice for thread safety.

ctl is an AtomicInteger object.AtomiInteger objects can manipulate variables, such as auto-increments, through CAS mechanisms.

CAS is CompareAndSwap, Compare and Replace.When the value of a variable is the expected value, modify it to the corresponding updated value.

For AtomicInteger and CAS, please refer to: https://www.cnblogs.com/expiator/p/9449298.html

The compareAndIncrementWorkerCount() method called in addWorker() above is as follows:

 * Attempts to CAS-increment the workerCount field of ctl.
private boolean compareAndIncrementWorkerCount(int expect) {
    return ctl.compareAndSet(expect, expect + 1);
* Atomically sets the value to the given updated value
* if the current value {@code ==} the expected value.
* @param expect the expected value
* @param update the new value
* @return {@code true} if successful. False return indicates that
* the actual value was not equal to the expected value.
public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);


Through task.run(); execute a task.

     * Main worker run loop.  Repeatedly gets tasks from queue and
     * executes them, while coping with a number of issues:
     * 1. We may start out with an initial task, in which case we
     * don't need to get the first one. Otherwise, as long as pool is
     * running, we get tasks from getTask. If it returns null then the
     * worker exits due to changed pool state or configuration
     * parameters.  Other exits result from exception throws in
     * external code, in which case completedAbruptly holds, which
     * usually leads processWorkerExit to replace this thread.
     * 2. Before running any task, the lock is acquired to prevent
     * other pool interrupts while the task is executing, and then we
     * ensure that unless pool is stopping, this thread does not have
     * its interrupt set.
     * 3. Each task run is preceded by a call to beforeExecute, which
     * might throw an exception, in which case we cause thread to die
     * (breaking loop with completedAbruptly true) without processing
     * the task.
     * 4. Assuming beforeExecute completes normally, we run the task,
     * gathering any of its thrown exceptions to send to afterExecute.
     * We separately handle RuntimeException, Error (both of which the
     * specs guarantee that we trap) and arbitrary Throwables.
     * Because we cannot rethrow Throwables within Runnable.run, we
     * wrap them within Errors on the way out (to the thread's
     * UncaughtExceptionHandler).  Any thrown exception also
     * conservatively causes thread to die.
     * 5. After task.run completes, we call afterExecute, which may
     * also throw an exception, which will also cause thread to
     * die. According to JLS Sec 14.20, this exception is the one that
     * will be in effect even if task.run throws.
     * The net effect of the exception mechanics is that afterExecute
     * and the thread's UncaughtExceptionHandler have as accurate
     * information as we can provide about any problems encountered by
     * user code.
     * @param w the worker
    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            //Get Tasks
            while (task != null || (task = getTask()) != null) {
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                    //Execute Tasks
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                } finally {
                    task = null;
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);


Remove the task from the work queue workQueue.

A workQueue is a BlockingQueue that can be counted from the queue using take() and poll() functions.

The difference is that if there is no data in the queue, take() is used and the thread await() waits.poll() does not wait and returns null directly.

     * Performs blocking or timed wait for a task, depending on
     * current configuration settings, or returns null if this worker
     * must exit because of any of:
     * 1. There are more than maximumPoolSize workers (due to
     *    a call to setMaximumPoolSize).
     * 2. The pool is stopped.
     * 3. The pool is shutdown and the queue is empty.
     * 4. This worker timed out waiting for a task, and timed-out
     *    workers are subject to termination (that is,
     *    {@code allowCoreThreadTimeOut || workerCount > corePoolSize})
     *    both before and after the timed wait, and if the queue is
     *    non-empty, this worker is not the last thread in the pool.
     * @return task, or null if the worker must exit, in which case
     *         workerCount is decremented
    private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                return null;

            int wc = workerCountOf(c);

            // Are workers subject to culling?
            //Whether timed processing is required, if allowCoreThreadTimeOut is set or if the number of current worker threads is greater than corePoolSize, timed processing is required
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;

            try {
                //A workQueue is a BlockingQueue that can be counted from the queue using take() and poll() functions.
                //The difference is that if there is no data in the queue, take() is used and the thread await() waits.poll() does not wait and returns null directly.
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;

Thread pool size

As mentioned earlier, in addWorker(), a new worker object is added to the HashSet collection workers.

The number of threads in the thread pool refers to the size of the workers Set.

     * Returns the current number of threads in the pool.
     * @return the number of threads
    public int getPoolSize() {
        final ReentrantLock mainLock = this.mainLock;
        try {
            // Remove rare and surprising possibility of
            // isTerminated() && getPoolSize() > 0
            return runStateAtLeast(ctl.get(), TIDYING) ? 0
                : workers.size();
        } finally {

Reference material

Code Out Efficiency

Tags: less

Posted on Sat, 04 Apr 2020 18:27:17 -0700 by razorsedgeuk