Java并发-线程池源码分析

半半半山

于 2024-01-24 12:24:29 发布

阅读量853

点赞数 23

分类专栏：并发编程文章标签：并发编程 Java线程池

本文链接：https://blog.csdn.net/xiumu_/article/details/135819034

版权

并发编程专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一张图理解线程池处理流程

线程池的五种状态

线程池的5种状态：RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED。

线程池各个状态切换框架图：

状态	说明	切换
RUNNING	能够接收新任务，以及对已添加的任务进行处理	线程池的初始化状态是RUNNING。
SHUTDOWN	不接收新任务，但能处理已添加的任务	调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN
STOP	不接收新任务，不处理已添加的任务，并且会中断正在处理的任务	调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) -> STOP
TIDYING	当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。	当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING
TERMINATED	线程池彻底终止，就变成TERMINATED状态	线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED

源码解析

ThreadPoolExecutor 一些重要的常量、变量、静态方法信息

// 初始RUNNING状态， 工作线程数0
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// 线程池最大线程容量，COUNT_BITS=29
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

// 3个高位的二进制数表示线程池的状态
// 高3位：111
private static final int RUNNING    = -1 << COUNT_BITS;
// 高3位：000
private static final int SHUTDOWN   =  0 << COUNT_BITS;
// 高3位：001
private static final int STOP       =  1 << COUNT_BITS;
// 高3位：010
private static final int TIDYING    =  2 << COUNT_BITS;
// 高3位：011
private static final int TERMINATED =  3 << COUNT_BITS;

// ctl拆包方法
private static int runStateOf(int c)     { return c & ~CAPACITY; }
private static int workerCountOf(int c)  { return c & CAPACITY; }
private static int ctlOf(int rs, int wc) { return rs | wc; }


/**
 * Set containing all worker threads in pool. Accessed only when
 * holding mainLock.
 */
private final HashSet<Worker> workers = new HashSet<Worker>();
// 工作队列
private final BlockingQueue<Runnable> workQueue;

下面具体看执行入口 ThreadPoolExecutor#execute方法

主要分三步

如果工作线程数小于核心线程数，那么创建核心线程执行
如果工作线程数大于等于核心线程数，那么将其加入到工作队列中排队
如果工作队列已满且小于最大线程数，那么交由非核心线程执行

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();

    int c = ctl.get();
    // 如果工作线程数小于核心线程数 添加一个 worker来执行任务
    if (workerCountOf(c) < corePoolSize) {
        // 添加任务成功 则直接返回
        if (addWorker(command, true)) 
            return;
        c = ctl.get();
    }
    // 下面是当前线程数大于等于核心线程数，或者刚刚 addWorker失败

    // 如果线程池状态为RUNNING 则将当前任务加入到工作队列
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 重新检查线程池状态如果线程池处于非运行状态 那么从工作队列中删除 
        if (! isRunning(recheck) && remove(command))
            // 走拒绝策略
            reject(command);
        // 如果工作线程为0 则添加工作线程
        else if (workerCountOf(recheck) == 0)
             // 当前任务已经在工作队列中所以没把command任务传入firstTask。 主要是防止任务提交到队列中但线程已经全部关闭了
            addWorker(null, false);
    }
    // 如果入队失败 那么新建工作任务给非核心线程执行
    else if (!addWorker(command, false))
        // addWorker处理失败 走拒绝策略
        reject(command); 
}

ThreadPoolExecutor#addWorker 添加worker，主要作用是在线程池中创建一个线程并执行参数传入的任务，或者工作队列里面排队的任务。

主要执行两个操作

自旋来增加worker数量
将新增的worker加入到workers中，同时启动线程t.start()

private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        // 运行状态非运行中 且 （运行状态STOP、TIDYING、TERMINATED 或 (SHUTDOWN && 任务不为空) 或 (SHUTDOWN && 工作队列为空)） 情况下不接受新任务。 
        // 其实也就是SHUTDOWN状态不可用处理新任务但可以处理已添加的任务， 而STOP、TIDYING、TERMINATED均不允许处理
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty())) 
            return false;
        // 自旋增加工作线程数
        for (;;) {
            int wc = workerCountOf(c);
            // 如果工作线程数量大于核心线程或者最大线程数，返回false
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize)) 
                return false;
            // 新增工作线程数并退出循环 进行后续开启线程逻辑
            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 {
        final ReentrantLock mainLock = this.mainLock;
        // 新建一个工作任务
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            mainLock.lock();
            try {
                // Recheck while holding lock.
                // Back out on ThreadFactory failure or if
                // shut down before lock acquired.
                int c = ctl.get();
                int rs = runStateOf(c);

                // 如果线程处于运行状态 或 （SHUTDOWN且任务为空） 前面已经将节点入队了，即时此处运行状态SHUTDOWN但还是可以处理
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) { 
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    workers.add(w);
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            // 线程执行
            if (workerAdded) {
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        //线程启动失败，则从wokers中移除w并递减wokerCount
        if (! workerStarted) 
            // 递减wokerCount会触发tryTerminate方法
            addWorkerFailed(w);  
    }
    return workerStarted;
}

下面看一下t.start() 线程执行的操作，在看线程执行之前得看一下Worker类结构

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{
    
    /** Thread this worker is running in.  Null if factory fails. */
    final Thread thread;
    /** Initial task to run.  Possibly null. */
    /** 第一个任务，可以为空，为空的场景worker类只用来新建线程，而任务task从工作队列中获取. */
    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;
        this.thread = getThreadFactory().newThread(this);
    }

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

}

看一下线程的具体执行ThreadPoolExecutor#runWorker

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        // task != null，直接执行该task
        // task == null，getTask() 从工作队列中获取task
        while (task != null || (task = getTask()) != null) {
            w.lock();
            // 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))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                // 钩子函数，任务执行前的操作
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    // 任务执行
                    task.run();
                } catch (RuntimeException x) {
                    ...
                } finally {
                    // 钩子函数，任务执行后的操作
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}