ThreadPoolExecutor 源码学习(一)

最新推荐文章于 2024-04-05 03:51:00 发布

lis）

最新推荐文章于 2024-04-05 03:51:00 发布

阅读量76

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/liso00/article/details/115356178

版权

java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

本文深入探讨了JDK11中线程池的工作原理，重点关注`addWorker`、`runWorker`和`processWorkerExit`等关键方法。通过分析这些方法的逻辑，揭示了线程池如何添加、管理和终止工作线程，以及在不同运行状态下如何调整线程数量和任务执行流程。

摘要由CSDN通过智能技术生成

JDK11

addWorker

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (int c = ctl.get();;) {
            
            if (runStateAtLeast(c, SHUTDOWN)    //当前运行状态是否>=SHUTDOWN SHUTDOWN不能添加Worker 可以获取Worker
                && (runStateAtLeast(c, STOP)    //当前运行状态是否>=STOP return false;
                    || firstTask != null        //状态SHUTDOWN + firstTask 存在 return false;
                    || workQueue.isEmpty()))    //状态SHUTDOWN + workQueue 为空 return false;
                return false;

            for (;;) {
                if (workerCountOf(c)                                            //工作线程是否大于等于 线程池最大任务数
                    >= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
                    return false;
                if (compareAndIncrementWorkerCount(c))                       //工作线程数 加一 如果成功 跳出循环
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateAtLeast(c, SHUTDOWN))       //当前运行状态是否>=SHUTDOWN  重试循环
                    continue retry;
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);  //创建一个任务 设置state为-1 不可被中断 
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    int c = ctl.get();

                    if (isRunning(c) ||
                        (runStateLessThan(c, STOP) && 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 {
            if (! workerStarted)  //任务启动失败 workerCountOf减一
                addWorkerFailed(w);
        }
        return workerStarted;
    }

runWorker

    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock();             // 清除addWorder中设置的state=-1 设置state=0 线程可以被中断
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                
                if ((runStateAtLeast(ctl.get(), STOP) ||              //1 判断线程池是否为 TIDYING TERMINATED 为true 则进入if
                     (Thread.interrupted() &&                         //2 interrupted 查看线程是否被中断清除中断标记 并且 runStateAtLeast判断线程池状态
                      runStateAtLeast(ctl.get(), STOP))) && 
                    !wt.isInterrupted())                              //2 wt.isInterrupted()
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    try {
                        task.run();
                        afterExecute(task, null);
                    } catch (Throwable ex) {
                        afterExecute(task, ex);
                        throw ex;
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;                     //beforeExecute、beforeExecute,用户控制可能会抛异常 这块就执行不到
        } finally {
            processWorkerExit(w, completedAbruptly); 
        }
    }

processWorkerExit

    private void processWorkerExit(Worker w, boolean completedAbruptly) {
        if (completedAbruptly) //如果前面程序出现异常 这块就不执行
            decrementWorkerCount();

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            completedTaskCount += w.completedTasks;
            workers.remove(w);
        } finally {
            mainLock.unlock();
        }

        tryTerminate();

        int c = ctl.get();
        if (runStateLessThan(c, STOP)) {
            if (!completedAbruptly) {
                int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
                if (min == 0 && ! workQueue.isEmpty())
                    min = 1;
                if (workerCountOf(c) >= min)
                    return; // replacement not needed
            }
            addWorker(null, false); //新增一个线程
        }
    }