目录

• 前言
• 为什么用线程池
• 参数介绍
• 核心线程数和最大线程数设置
• 使用示例
• 线程池执行任务的流程
• 线程池执行流程图
• 源码解读
• 基础属性和变量
• execute(Runnable command)
• addWorker(Runnable firstTask, boolean core)
• runWorker(this)
• processWorkerExit(Worker w, boolean completedAbruptly)
• getTask()
• shutdown()
• 总结

前言

多线程编程是现代软件开发中不可或缺的一部分，但是手动管理线程可能会变得非常复杂，因为需要考虑许多并发问题，例如线程安全和资源竞争。为了避免这些问题，Java提供了ThreadPoolExecutor类，它是一种高度优化的多线程执行器，可以管理线程池、执行线程任务和控制线程池的大小和生命周期等

为什么用线程池

• 线程创建和销毁的开销较大，每个线程都需要占用一定的内存和系统资源。如果频繁地创建和销毁线程，会导致系统的性能下降。
• 手动管理线程容易出现线程安全和资源竞争的问题，例如，多个线程同时访问共享变量可能导致数据不一致或者死锁等问题。
• 如果并发访问的线程数量很大，可能会导致系统资源不足，例如，内存不足或者CPU过度使用等问题。

参数介绍

• corePoolSize：核心线程池大小，即线程池中始终存在的线程数量，除非设置了allowCoreThreadTimeOut参数，默认情况下，即使空闲，核心线程也不会被回收。
• maximumPoolSize：线程池的最大线程数，即可以同时执行的最大线程数量。
• keepAliveTime：非核心线程的空闲存活时间，当非核心线程空闲时间超过这个时间，就会被回收。
• unit：keepAliveTime的时间单位。
• workQueue：任务队列，用于存储等待执行的任务，有多种实现方式，例如ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等。
• threadFactory：用于创建新线程的工厂类，可以自定义线程名称、线程优先级等属性。
• handler：线程池的拒绝策略，当线程池已经达到最大线程数，并且任务队列已经满了，新的任务将被拒绝执行，可以设置拒绝策略来处理这种情况。

核心线程数和最大线程数设置

• CPU密集型任务:CPU密集型任务的特点是线程在执行任务时会一直利用CPU，对于这种情况要尽可能的避免发生线程上下文的切换。一般来说对于CPU密集型任务设置线程数为CPU核心数+1。
• IO密集型任务:线程在执行IO密集型任务时,可能大部分时间都浪费在阻塞IO上了，所以对于IO密集型任务来说我们通常会设置线程数为CPU核心数*2。不过这样子也不一定是最佳的，我们可以通过公式来进行计算:线程数 = CPU 核心数 *（1+平均等待时间/平均工作时间）,尽可能的还要根据压缩来进行调整。

使用示例

public class CustomThreadPoolDemo  {
    public static void main(String[] args) {
        // 创建线程池，大小为3，最大线程数为6，空闲线程存活时间为5秒，使用自定义线程工厂和拒绝策略
        ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 5, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(10), new CustomThreadFactory(), new CustomRejectedExecutionHandler());
        // 提交10个任务
        for (int i = 0; i < 10; i++) {
            executor.submit(new Task(i));
        }
        // 关闭线程池
        executor.shutdown();
    }
    static class Task implements Runnable {
        private int taskId;
        public Task(int taskId) {
            this.taskId = taskId;
        }
        @Override
        public void run() {
            System.out.println("Task " + taskId + " is running in thread " + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Task " + taskId + " is done.");
        }
    }
    static class CustomThreadFactory implements java.util.concurrent.ThreadFactory {
        private int count = 1;
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setName("CustomThreadPool-" + count++);
            return t;
        }
    }
    static class CustomRejectedExecutionHandler implements java.util.concurrent.RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            System.out.println("Task " + ((Task) r).taskId + " is rejected.");
        }
    }
}

该示例代码使用ThreadPoolExecutor类创建了一个大小为3，最大线程数为6，空闲线程存活时间为5秒的线程池，任务队列的大小为10，使用了自定义的线程工厂和拒绝策略。然后提交了10个任务，每个任务输出了当前线程的名称，并休眠了3秒钟。当程序执行时，可能会出现任务被拒绝执行的情况，拒绝策略会输出任务被拒绝的信息。

线程池执行任务的流程

ThreadPoolExecutor提供了两种执行任务的方法:

Future<?> submit(Runnable task) 
void execute(Runnable command)

实际上submit中也是调用了execute方法

public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<Void> ftask = newTaskFor(task, null);
    execute(ftask);
    return ftask;
}

线程池执行流程图

源码解读

基础属性和变量

private final AtomicInteger ctl

线程池源码中使用ctl通过高低位的方式来记录线程池的状态和当前线程池中的工作线程数量。

Integer占用4个字节也就是32位，线程池有5种状态，要标识5种状态需要3位

前三位

private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
// runState is stored in the high-order bits
private static final int RUNNING    = -1 << COUNT_BITS;
private static final int SHUTDOWN   =  0 << COUNT_BITS;
private static final int STOP       =  1 << COUNT_BITS;
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;

Integer.SIZE为32，所以COUNT_BITS为29，最终各个状态对应的二级制为：

RUNNING：11100000 00000000 00000000 00000000

SHUTDOWN：00000000 00000000 00000000 00000000

STOP：00100000 00000000 00000000 00000000

TIDYING：01000000 00000000 00000000 00000000

TERMINATED：01100000 00000000 00000000 00000000

execute(Runnable command)

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    //ctl初始值是ctlOf(RUNNING, 0)，表示线程池处于运行中，工作线程数为0
    int c = ctl.get();
    //判断工作线程是否小于核心线程数
    if (workerCountOf(c) < corePoolSize) {
        //小于核心线程要新增工作线程
        if (addWorker(command, true))
            return;
        //新增失败重新获取一次ctl
        c = ctl.get();
    }
    //线程池是否处于Running状态 && 入队是否成功
    if (isRunning(c) && workQueue.offer(command)) {//入队成功
        //重新获取ctl
        int recheck = ctl.get();
        //如果线程池不是Running状态就需要移除掉这个任务
        if (! isRunning(recheck) && remove(command))
            //触发拒绝策略
            reject(command);
             //工作线程为0时要去创建新的工作线程
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 如果线程池状态不是RUNNING，或者线程池状态是RUNNING但是队列满了，则去添加一个非核心工作线程。false表示非核心线程
    else if (!addWorker(command, false))
        reject(command);
}

addWorker(Runnable firstTask, boolean core)

//core:true核心线程 false非核心线程
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        //获取ctl值
        int c = ctl.get();
        //获取高3位
        int rs = runStateOf(c);
        // 线程池如果是SHUTDOWN状态并且队列非空则创建线程，如果队列为空则不创建线程
        // 线程池如果是STOP状态则直接不创建线程
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;
        for (;;) {
            //获取工作线程数
            int wc = workerCountOf(c);
            //工作线程数超过规定数量则不创建线程
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            //修改工作线程
            if (compareAndIncrementWorkerCount(c))
               //成功则退出 retry这个循环
                break retry;
            //CAS失败说明有其他线程也在增加工作线程数量，此时重新获取ctl值
            c = ctl.get();  // Re-read ctl
            //如果发现线程池的状态发生了变化，则继续回到retry，重新判断线程池的状态是不是SHUTDOWN或STOP
            // 如果状态没有变化，则继续利用cas来增加工作线程数，直到cas成功
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }
    //到了这里说明ctl新增成功
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        //Worker实现了Runnable接口 在构造一个Worker对象时，就会利用ThreadFactory新建一个线程
        w = new Worker(firstTask);
        //拿出线程对象此时线程还没有start启动
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                // 获取高三位
                int rs = runStateOf(ctl.get());
                // 如果线程池的状态是RUNNING
                // 或者线程池的状态变成了SHUTDOWN，但是当前线程没有自己的第一个任务，那就表示当前调用addWorker方法是为了从队列中获取任务来执行
                // 正常情况下线程池的状态如果是SHUTDOWN，是不能创建新的工作线程的，但是队列中如果有任务，那就是上面说的特例情况
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    // 如果Worker对象对应的线程已经在运行了，那就有问题，直接抛异常
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    // workers用来记录当前线程池中工作线程，调用线程池的shutdown方法时会遍历worker对象中断对应线程
                    workers.add(w);
                    int s = workers.size();
                    // largestPoolSize用来跟踪线程池在运行过程中工作线程数的峰值
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            //启动线程
            if (workerAdded) {
                t.start();
                workerStarted = true;
            }
        }
    } finally {
    // 在上述过程中如果抛了异常，需要从works中移除所添加的work，并且还要修改ctl，工作线程数-1，表示新建工作线程失败
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

addWorker核心逻辑:

• 先判断工作线程数是否超过了限制
• 修改ctl，使得工作线程数+1
• 构造Work对象，并把它添加到workers集合中
• 启动Work对象对应的工作线程

runWorker(this)

刚刚有说到Worker实现了Runnable接口,看看他重写的Run方法中执行过什么

Worker(Runnable firstTask) {
    setState(-1); // inhibit interrupts until runWorker
    this.firstTask = firstTask;
    this.thread = getThreadFactory().newThread(this);
}
/** Delegates main run loop to outer runWorker  */
public void run() {
    runWorker(this);
}
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()方法中
        //也不会一直阻塞下去，keepAliveTime超时后还没有获取到任务就会返回null，退出循环，这个线程也就是中止了
        while (task != null || (task = getTask()) != null) {
            w.lock();
            //线程池状态为STOP，则要中断自己，但是如果发现中断标记为true，那是不对的，因为线程池状态不是STOP，工作线程仍然是要正常工作的，不能中断掉，算是SHUTDOWN，也要等任务都执行完之后，线程才结束，而目前线程还在执行任务的过程中，不能中断
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                //空方法给自定义线程池实现
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    //执行任务
                    task.run();
                } 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;
                w.completedTasks++;
                w.unlock();
            }
        }
        //正常退出了while循环
        // completedAbruptly=false，表示线程正常退出
        completedAbruptly = false;
    } finally {
        //如果线程正常退出这个线程会自然死亡
        //但是如果是由于执行任务的时候抛了异常，那么这个线程不应该直接结束，而应该继续从队列中获取下一个任务
        processWorkerExit(w, completedAbruptly);
    }
}

processWorkerExit(Worker w, boolean completedAbruptly)

private void processWorkerExit(Worker w, boolean completedAbruptly) {
   //如果completedAbruptly为true，表示是执行任务的时候抛了异常，那就修改ctl，工作线程数-1
    if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
        decrementWorkerCount();
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        completedTaskCount += w.completedTasks;
        // 将当前Work对象从workers中移除
        workers.remove(w);
    } finally {
        mainLock.unlock();
    }
    // 因为当前是处理线程退出流程中，所以要尝试去修改线程池的状态为TINDYING
    tryTerminate();
    //获取当前ctl值
    int c = ctl.get();
    // 如果线程池的状态为RUNNING或者SHUTDOWN，则可能要替补一个线程
    if (runStateLessThan(c, STOP)) {
        // completedAbruptly为false，表示线程是正常要退出了，则看是否需要保留线程
        if (!completedAbruptly) {
        // 如果allowCoreThreadTimeOut为true，但是阻塞队列中还有任务，那就至少得保留一个工作线程来处理阻塞队列中的任务
        // 如果allowCoreThreadTimeOut为false，那min就是corePoolSize，表示至少得保留corePoolSize个工作线程活着
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            if (min == 0 && ! workQueue.isEmpty())
                min = 1;
            // 如果当前工作线程数大于等于min，则表示符合所需要保留的最小线程数，那就直接return，不会调用下面的addWorker方法新开一个工作线程了
            if (workerCountOf(c) >= min)
                return; // replacement not needed
        }
        //新开工作线程
        addWorker(null, false);
    }
}

某个工作线程正常情况下会不停的循环从阻塞队列中获取任务来执行，正常情况下就是通过阻塞来保证线程永远活着，但是会有一些特殊情况：

• 如果线程被中断了，那就会退出循环，然后做一些善后处理，比如ctl中的工作线程数-1，然后自己运行结束
• 如果线程阻塞超时了，那也会退出循环，此时就需要判断线程池中的当前工作线程够不够，比如是否有corePoolSize个工作线程，如果不够就需要新开一个线程，然后当前线程自己运行结束，这种看上去效率比较低，但是也没办法，当然如果当前工作线程数足够，那就正常，自己正常的运行结束即可
• 如果线程是在执行任务的时候抛了移除，从而退出循环，那就直接新开一个线程作为替补，当然前提是线程池的状态是RUNNING

getTask()

private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
        // 如果线程池状态是STOP，表示当前线程不需要处理任务了，那就修改ctl工作线程数-1
        // 如果线程池状态是SHUTDOWN，但是阻塞队列中为空，表示当前任务没有任务要处理了，那就修改ctl工作线程数-1
        // return null表示当前线程无需处理任务，线程退出
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }
        //当前工作线程数
        int wc = workerCountOf(c);
        // 用来判断当前线程是无限阻塞还是超时阻塞，如果一个线程超时阻塞，那么一旦超时了，那么这个线程最终就会退出
        // 如果是无限阻塞，那除非被中断了，不然这个线程就一直等着获取队列中的任务
        // allowCoreThreadTimeOut为true，表示线程池中的所有线程都可以被回收掉，则当前线程应该直接使用超时阻塞，一旦超时就回收
        // allowCoreThreadTimeOut为false，则要看当前工作线程数是否超过了corePoolSize，如果超过了，则表示超过部分的线程要用超时阻塞，一旦超时就回收
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
        // 如果工作线程数超过了工作线程的最大限制或者线程超时了，则要修改ctl，工作线程数减1，并且return null
        // return null就会导致外层的while循环退出，从而导致线程直接运行结束
        // 直播课程里会细讲timed && timedOut
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }
        try {
            // 要么超时阻塞，要么无限阻塞
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            // 表示没有超时，在阻塞期间获取到了任务
            if (r != null)
                return r;
            // 超时了，重新进入循环，上面的代码会判断出来当前线程阻塞超时了，最后return null，线程会运行结束
            timedOut = true;
        } catch (InterruptedException retry) {
        // 如果线程池的状态变成了STOP或者SHUTDOWN，最终也会return null，线程会运行结束
        // 但是如果线程池的状态仍然是RUNNING，那当前线程会继续从队列中去获取任务，表示忽略了本次中断
        // 只有通过调用线程池的shutdown方法或shutdownNow方法才能真正中断线程池中的线程
            timedOut = false;
        }
    }
}

shutdown()

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        // 修改ctl，将线程池状态改为SHUTDOWN
        advanceRunState(SHUTDOWN);
        // 中断工作线程
        interruptIdleWorkers();
        // 空方法，给子类扩展使用
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
}
private void interruptIdleWorkers(boolean onlyOne) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        // 遍历所有正在工作的线程，要么在执行任务，要么在阻塞等待任务
        for (Worker w : workers) {
            Thread t = w.thread;
            // 如果线程没有被中断，并且能够拿到锁，就中断线程
            // Worker在执行任务时会先加锁，执行完任务之后会释放锁
            // 所以只要这里拿到了锁，就表示线程空出来了，可以中断了
            if (!t.isInterrupted() && w.tryLock()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                } finally {
                    w.unlock();
                }
            }
            if (onlyOne)
                break;
        }
    } finally {
        mainLock.unlock();
    }
}

总结

ThreadPoolExecutor是Java并发编程中非常重要的一个类，它可以优化多线程编程的效率和可靠性。在本文中，我们深入探讨了ThreadPoolExecutor的实现原理、工作机制和使用方法，总结如下：

首先，ThreadPoolExecutor是一种高度优化的多线程执行器，它可以管理线程池、执行线程任务和控制线程池的大小和生命周期等。ThreadPoolExecutor的实现基于生产者-消费者模型，它可以根据任务队列中的任务数量自动调整线程池的大小，从而实现对系统资源的最优利用。

其次，ThreadPoolExecutor的使用非常灵活，可以通过配置ThreadPoolExecutor的参数来实现不同的线程池策略，例如核心线程数、最大线程数、任务队列类型、拒绝策略等。此外，ThreadPoolExecutor还提供了一些重要的方法，例如submit()、execute()和shutdown()等，用于提交任务、执行任务和关闭线程池。

最后，在高并发环境下，应尽可能避免使用无界队列，以防止内存泄漏和系统资源耗尽。此外，还可以通过使用线程池监视器和线程池饱和策略来监控线程池的状态和性能，以确保系统的稳定性和可靠性。