Concurrency_The principle and application of thread pool

java thread pool knowledge summary.

Thread pool parameter meaning

  • int corePoolSize

The number of core threads, that is, the number of worker threads under normal circumstances

  • int maximumPoolSize,

maximum number of threads

  • long keepAliveTime,

It needs to be understood in conjunction with the blocking queue: suppose the length of the blocking queue is 3, the number of cores is 2, and the maximum number of threads is 5. The runtime is like this: when the number of cores is greater than the number of cores, it will be placed in the blocking queue, and only if the queue is full New worker threads are enabled until the maximum number of threads is reached
When the maximum number of threads is reached, if the task submit ted to the thread pool becomes slower and the core thread can handle the work, the thread pool will dynamically reduce the number of worker threads to the number of core threads. The keepAliveTime here refers to the idle time of the threads other than the core thread. If it is larger than this parameter, the thread pool will recycle these threads

  • TimeUnit unit,

the unit of the third parameter

  • BlockingQueue<Runnable> workQueue,

Threads that exceed the number of core threads will be queued in the blocking queue. Do not use the Executors.newFixedThreadPool method to construct, the default size of the specified blocking queue (LinkedBlockingQueue) is Integer.MAX_VALUE, which needs to be specified explicitly

  • ThreadFactory threadFactory,

Just use the default, distinguish the thread name if necessary

  • RejectedExecutionHandler handler

Denial Policy:

AbortPolicy (default): throw exception directly
DiscardPolicy: Randomly discard
DiscardOldestPolicy: Discard the oldest thread
CallerRunsPolicy: Return execution to the caller thread.

Source code analysis

  • Preliminary knowledge (bit operations)
  1. Original code (with sign bit): the highest bit is the sign bit, negative numbers are 1, positive numbers are 0
  2. Complement code: The original code except the sign bit, and the remaining bits are inverted.
  3. Two's complement (mainly used to represent negative numbers): Signed negative number's complement + 1, mainly to eliminate -0, only negative numbers are represented by complement. refer:
  • How to save thread state

In the thread pool, the first three digits represent the running state, and the last 29 digits represent the number of worker threads.

  // 29 
  private static final int COUNT_BITS = Integer.SIZE - 3;
  //1 (original code representation) left shift by 29 bits + (-1)'s complement (32 bits 1), the first three bits are 0, and the last 29 bits are 1 
  private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
  //Take the last 29 digits
  private static int workerCountOf(int c)  { return c & CAPACITY; }
  //The negation of CAPACITY means that the first three bits are 1, and the last 29 bits are 0, so any AND operation with ~CAPACITY will only keep the first 3 bits. 
  private static int runStateOf(int c)     { return c & ~CAPACITY; }
  • task management

submit The execution logic after submitting the task

        int c = ctl.get();
        //If the number of threads in the last 29 bits has not exceeded the number of cores, addWorker updates the number of threads (the last 29 bits of ctl)
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
            c = ctl.get();
        //If the number of core threads is greater than the number of core threads, the status will be re-acquired. If the thread pool is still running, the task will be put into the blocking queue.
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            //If the thread pool is no longer running, reject it directly
            if (! isRunning(recheck) && remove(command))
            else if (workerCountOf(recheck) == 0)
                //The first thread is empty and executes immediately, see the Worker class method
                addWorker(null, false);
        //Call the addWorker method to update the number of ctl running threads 
        else if (!addWorker(command, false))
  • Worker thread management

In order to manage the life cycle of the Worker thread, the Worker thread is designed. It is worth mentioning that the Worker thread is an AQS, which will be locked before running. It will be unlocked after running.
Relying on this, when you want to interrupt these idle threads, you can judge whether the worker thread is running by whether it can be successfully locked. If the interrupt operation can be successfully locked, it means
The thread is no longer running, then you can call the interrupt method of the worker thread to interrupt the thread, and remove the worker thread reference in the hashSet. Wait for the jvm to recycle

  final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            //getTask gets runnable from blocking queue, and then runs 
            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 queue 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 {
            //If the task in the blocking queue is empty, execute the recycling logic
            //All worker thread references will be kept in a hashSet,
            processWorkerExit(w, completedAbruptly);
    //interrupt idle thread
    private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        try {
            for (Worker w : workers) {
                Thread t = w.thread;
                //If the worker thread is not interrupted and the lock is successful, the interrupt operation is performed 
                if (!t.isInterrupted() && w.tryLock()) {
                    try {
                    } catch (SecurityException ignore) {
                    } finally {
                if (onlyOne)
        } finally {


  • How much is the thread pool?

From experience, it is necessary to distinguish whether it is cpu-intensive or io-intensive. If the cpu is intensive, in order to avoid context switching, the number should not be too much, generally the number of cpu cores + 1;
If it is io-intensive, it can be more, and it is necessary to roughly clarify the ratio of the time-consuming of io-type tasks to the time-consuming of cpu-intensive tasks.

  • Deadlock coding and location

jstack troubleshooting

  • ExecutorService.submit(Runnable task, T result) should be used like this

The result is used as a bridge between the child thread and the main thread, and is passed into the task as a construction parameter. The child thread can operate the result object.

Tags: thread pool

Posted by screamer141 on Fri, 03 Jun 2022 15:43:46 +0530