其他分享
首页 > 其他分享> > 一次线上线程池任务事故

一次线上线程池任务事故

作者:互联网

前言

线上出现线程池提交任务抛出 RejectedExecutionException 异常

即任务提交执行了拒绝策略的操作。查看业务情况和线程池配置,发现并行执行的任务数是小于线程池最大线程数的。以下是排查过程

一、业务场景

1.1. 任务描述

每次执行一组任务,一组任务最多有 15 个,多线程执行,每个线程处理一个任务;每次执行完一组任务后,再执行下一组,不存在上一组的任务和下一组一起执行的情况。

1.2. 任务提交流程

① 任务开始 ➠

② 获取一组任务 ➠

③ 将任务提交到线程池 ➠

④ Future#get()阻塞等待,直到整组任务执行完成 ➠

⑤ 转到②获取下一批可执行的任务

1.3. 线程池配置

<bean id="executor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
    <property name="corePoolSize" value="14"/>
    <property name="maxPoolSize" value="30"/>
    <property name="queueCapacity" value="1"/>
</bean>

二、出现问题

执行过程中出现 RejectedExecutionException 异常,由于是采用的是默认拒绝策略AbortPolicy

因此,可以明确知道任务是提交到线程池后,线程池资源已满,导致任务被拒绝

三、问题排查

3.1. 检查线程池配置

任务最多 15 个一组,核心线程有 14 个,阻塞队列是 1,最大线程 30

理论上 14 个核心线程+1 个阻塞队列即可完成一组任务,连非核心线程都无需使用,为什么会出现线程被占满的情况?

3.2. 检查业务代码

检查是否存在线程池被多处使用,或者有多批任务被同时执行的情况,并没有发现错误;

3.3. 线下重现

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<!--自定义配置bean-->
    <bean id="executor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <property name="corePoolSize" value="14"/>
        <property name="maxPoolSize" value="30"/>
        <property name="queueCapacity" value="1"/>
    </bean>
</beans>

@SpringBootApplication
@ImportResource(locations = {"classpath:executeBeanConfig.xml"}) // 扫描xml
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}
@RunWith(SpringRunner.class)
@SpringBootTest
public class Tests {

    @Resource
    private ThreadPoolTaskExecutor executor;

    @Test
    public void contextLoads() throws Exception {
        // 一共 10 批任务
        for(int i = 0; i < 10; i++) {
            // 每次执行一批任务
            doOnceTasks();
            System.out.println("---------------------------------------" + i);
        }
    }

    /**
     * 每次完成 15 个任务后,再进行下一次任务
     */
    private void doOnceTasks(){
        List<Future> futureList = Lists.newArrayListWithCapacity(15);
        for(int i = 0; i < 15; ++i){
            Future future = executor.submit(()->{
                // 随机睡 0-5 秒
                int sec = new Double(Math.random() * 5).intValue();
                LockSupport.parkNanos(sec * 1000 * 1000 * 1000);
                System.out.println(Thread.currentThread().getName() + "  end");
            });
            futureList.add(future);
        }

        // 等待所有任务执行结束
        for(Future future : futureList){
            try {
                future.get();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

用executor.submit()方法提交任务,主要是为了利用Future来获取任务执行结果
:::tip 补充知识点

四、线程池源码阅读

4.1. 线程池执行任务流程

image.png

一些参数:

即在没有任务到来之前就创建corePoolSize个线程或者一个线程。
默认情况下,在创建了线程池后,线程池中的线程数为0,当有任务来之后,就会创建一个线程去执行任务,当线程池中的线程数目达到corePoolSize后,就会把到达的任务放到缓存队列当中;

ArrayBlockingQueue和PriorityBlockingQueue使用较少,一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。【阻塞队列的选择,下面有讲解】

4.2. execute 线程池提交任务源码

class ThreadPoolExecutor{
    public void execute(Runnable command) {
        // 提交任务不能为 null
        if (command == null)
            throw new NullPointerException();

        // 获取控制位 ctl 的值
        int c = ctl.get();
        // work 线程数 < 核心线程数
        if (workerCountOf(c) < corePoolSize) {
            // 直接创建核心线程,执行任务
            if (addWorker(command, true))
                return;

            /*
                因为没有使用锁,可能会出现并发创建核心线程;
                走到这里,说明核心线程已经创建满了,此时,重新获取控制位 ctl 的值
              */
            c = ctl.get();
        }

        // 如果线程池还是 RUNNING 状态,并且任务成功提交到阻塞队列中
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            // double-check,再检查一次线程池状态
            // 如果线程池变成非 RUNNING 状态,则回滚刚才新加的任务
            if (! isRunning(recheck) && remove(command))
                // 从阻塞队列中移除任务成功,使用拒绝策略执行任务
                reject(command);

            // 如果工作线程数==0,则添加一个线程
            // 主要是兼容核心线程数==0 的情况
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }

        /*
            到达这里,则说明核心线程数已满,且阻塞队列已满
            尝试创建非核心线程执行任务
        */
        else if (!addWorker(command, false))
            // 非核心线程创建失败了,说明是线程数以达到 maximumPoolSize,此时执行拒绝策略
            reject(command);
    }
}

4.3. addWorker 添加 worker 线程

class ThreadPoolExecutor{
    /**
     * 添加一个 worker 线程
     * @param firstTask 第一个要执行的 task
     * @param core 是否是核心线程
     * @return 创建成功还是失败
     */
    private boolean addWorker(Runnable firstTask, boolean core) {
        // 定义了一个 retry 标签
        retry:
        for (;;) {
            // 获取控制位
            int c = ctl.get();
            // 获取运行状态
            int rs = runStateOf(c);

            /**
             * rs >= SHUTDOWN:即非 RUNNING 状态,只有 RUNNING < SHUTDOWN
             * ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())
             *      等价于 非 SHUTDOWN 态 ||  firstTask != null || workQueue.isEmpty()
             *      非 SHUTDOWN 态 == true:SHUTDOWN 态之后的状态,都不允许再添加 worker 线程了,直接返回 false;
             *      非 SHUTDOWN 态 == false || (firstTask != null) == true:SHUTDOWN 状态下,不允许再添加任务了,返回 false;
             *      非 SHUTDOWN 态 == false || (firstTask != null) == false || workQueue.isEmpty() == true:SHUTDOWN 状态,没提交新任务,阻塞队列又是空的,没必要再添加线程了
             */
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            // CAS 创建 worker 线程
            for (;;) {
                // 获取线程数
                int wc = workerCountOf(c);
                /*
                当前线程数大于最大值
                    或
                当前创建的是核心线程,但线程数量已经>=核心线程数
                    或
                当前创建非核心线程,但线程数量已经>=maximumPoolSize
                */
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    // 不创建,直接返回 false
                    return false;

                // cas 修改 ctl 中的线程数,线程数+1
                if (compareAndIncrementWorkerCount(c))
                    // cas 修改成功,break goto 结束循环(不会再进入标签下的循环)
                    break retry;

                // 达到这里,说明 cas 增加线程数 1 失败了,此时进行尝试
                c = ctl.get();
                // 先判断一下线程池状态有没有改变,如果改变了,则 continue goto(会再进入标签下的循环)
                // 跳转到最外层的循环,重新检测线程池的状态值
                if (runStateOf(c) != rs)
                    continue retry;
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            // 创建 worker 对象
            w = new Worker(firstTask);
            // 获取 worker 的线程
            final Thread t = w.thread;
            if (t != null) {
                // 加锁
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // 获取线程池状态
                    int rs = runStateOf(ctl.get());

                    /*
                     线程池是 RUNNING 状态
                        或
                     SHUTDOWN 态 且 firstTask == null(这种情况是需要创建线程,消费队列中剩余的任务)
                      */
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        // 线程是活动状态,则不合法,因为线程是刚创建的,应该是 NEW 状态
                        if (t.isAlive())
                            throw new IllegalThreadStateException();

                        // 将 worker 添加到 list 中
                        workers.add(w);
                        // largestPoolSize 记录该线程池使用过程中,达到最大的线程数
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        // worker 添加成功,workerAdded 置为 true
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }

                // worker 添加成功,此时就可以启动线程
                if (workerAdded) {
                    t.start();
                    // 启动线程成功,workerStarted 置为 true
                    workerStarted = true;
                }
            }
        } finally {
            // 如果 worker 启动失败,则移除它
            if (! workerStarted)
                // workers 移除新加的 worker,并在 ctl 中将 work 线程数量-1
                addWorkerFailed(w);
        }
        return workerStarted;
    }
}

五、问题定位

5.1. 定位执行拒绝策略入口

执行拒绝策略的位置只有这两个地方,在这两个地方打上断点,执行 demo,结果发现拒绝策略是在第二处执行的;

image.png

5.2. 定位执行拒绝策略原因

进入 addWorker 方法,只有这两个地方返回 false,创建线程失败,打断点,执行 demo,发现是在第二处返回 false 的;

image.png

六、问题确认

确实是创建的 worker 线程已经达到最大线程数,无法再创建,然后执行拒绝策略的

为什么会被创建到最大呢,每组任务最大只有 15 个,为什么会用到非核心线程?

七、定位原因

7.1. 分析 execute 方法

在添加非核心线程前,先尝试将任务放到阻塞队列中,如果阻塞队列已满,则尝试添加非核心线程,也就是说,创建非核心线程时:workQueue.offer(command) == false,即阻塞队列已满;
image.png

7.2. 猜测原因

因为我们阻塞队列只有 1,会不会提交任务的速度比线程从阻塞队列取任务的速度快,进而导致创建非核心线程执行任务,最终的结果就是:在多批任务之后,再无非核心线程可创建,导致执行拒绝策略。

7.3. 原因验证

阻塞队列选择
查看 Spring 的 ThreadPoolTaskExecutor 源码,发现

如果阻塞队列数量>0,则使用 LinkedBlockingQueue,否则使用 SynchronousQueue。

image.png

LinkedBlockingQueue

class LinkedBlockingQueue{
    private void signalNotEmpty() {
        final ReentrantLock takeLock = this.takeLock;
        // 加锁
        takeLock.lock();
        try {
            // 唤醒一个 take 线程
            notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
    }
}

八、解决方式

8.1. 使用 SynchronousQueue

使用 SynchronousQueue,即阻塞队列大小设置为 0
原因在于:SynchronousQueue 和 LinkedBlockingQueue 维度不一致
➢ SynchronousQueue 是根据是否有等待线程而决定是否入队成功
➢ LinkedBlockingQueue 是根据缓冲区,而不管是否已经有等待线程。

image.png image.png

8.2. 根据业务情况配置阻塞队列

对于我们的业务情况,因为任务最多只有 15 个,将阻塞队列大小设置为 15,这样就保证了不会出现任务被拒绝。

标签:上线,事故,队列,创建,阻塞,任务,程池,线程,执行
来源: https://blog.csdn.net/qq_33188180/article/details/122578110