线程池执行父子任务，导致线程死锁

已于 2023-09-08 17:10:39 修改
阅读量1.7k 收藏 8
点赞数 7
分类专栏： 多线程 文章标签： excel 数据库 java
于 2023-03-05 19:06:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ql_7256/article/details/129347738
版权

前言，

一次线程池的不当使用，导致了现场出现了线程死锁，接口一直不返回。而且由于这是一个公共的线程池，其他使用了次线程池的业务也一直阻塞，系统出现了OOM，不过是幸好是线程同事测试出来的，没有直接在生产坏境中出现这种事故，否则后果不堪设想。

具体情况

我接到一个需求，需要在多个excel中，根据excel中数据的关联关系，拼接出完整的记录，然后入库。其实这种情况，跟数据库中表情况挺类似的，如果将excel必做数据库中的表，就是几个表有数据，需要根据关联关系，写一个查询SQL，将查询出来的结果入库到另一张表中。

举个例子，虽然不太恰当，但是能说明情况

excel关系

学生excel、学生信息excel、详细住址excel之间的关系是一对一对一，一条学生对应一条学生信息，一条学生信息对应一条详细住址。现在就是要将这三个excel中的记录，拼接成一条完整的记录，然后入库，每个excel中都有上万条记录。这里是excel不是数据库，没法写SQL。感觉此时就像自己来实现SQL的连表逻辑，多层循环，第一层遍历学生excel的数据，拿到一条学生数据之后再遍历第学生信息excel，根据学生ID去学生信息exe找找到学生信息记录，如果还有一层关联关系，就还得套一层循环。

当然，这是最原始的想法，但是我不想这么做，一个表上万条记录，再套三层循环，效率很低了，而且就算三层循环跑完了，组装出来的上万条记录，也不可能一次性就能入库。所以我采用了线程池，我是这么想的：

  1. 那么多记录，使用线程分批处理，每个线程处理一批数据，每个批次1000条记录，相当于每次入库1000条。
  2. 当根据学生ID拿到一条学生信息记录之后，再使用线程池，分批去遍历详细住址excel，分批寻找，找到记录就起来，待所有的线程执行完成之后，将找到的记录返回去，再拼接起来，就成了完成的记录。

大概流程如下
线程池执行父子任务

task1，就是分批处理学生excel，拿到每个学生记录，再去循环学生信息excel，找到唯一的记录，进行拼接，然后再使用线程池，执行task2，根据信息ID，去分批遍历详细住址excel，找到详细住址记录，再将其拼接，最终拼接成唯一的记录，返回，入库。

原因分析

写完代码之后，我自己造了一些数据进行测试，没得问题，测试也造了一些数据测试，也没发现这个问题。(没有进行大量数据进行性能测试)，丢给现场，现场同事使用真实数据进行验证的时候出了问题。为啥自测和测试同事测试都没问题，而现场同事验证就出了问题呢？本质的原因就是数据量，自测和测试同事在测试时造的数据数据量都很小，一旦数据量大了就会出现问题。

数据量小的时候，task1使用线程池中的线程，没用使用完，线程池中还有剩余的线程，所以task1执行到需要条用task2时，还有多余的线程去执行task2。而一旦数据量比较大的时候，执行到task1时，就直接将线程池中所有的线程占用完了，线程池中的所有线程都在执行task1，然后执行到需要调用task2时，又要到线程池中去获取线程，结果此时已经没有多余的线程了，task1就阻塞了，等待线程池中有空余的线程。但线程池中所有的线程都阻塞在调用task2处，都在等待，就形成了线程死锁。

解决办法

当然，出现这个问题，说明我们在设计之初就有漏洞，最正确的做法应该是设计时就不要让同一个线程池执行父子任务。那既然出现了这个问题，该如何解决呢？或者说，这个情况正确的设计是什么呢？我觉得有两个方向：

  1. 如果系统资源足够：那么就再创建一个线程池，让task2使用另一个线程池，相互独立，那么就不会出现线程死锁
  2. 如果系统资源不够：那么task2就不使用线程池进行执行，将其合入task1，。

两种方式的比较：

如果最初在设计时，我更倾向于使用方式2，因为task1将所有的线程都占满了，那说明线程池的利用率已经是最高了，将task2合入task1成一个任务，也没有什么不妥。而如果一味的去新建线程池，有滥用系统资源的嫌疑。

但是我现在的情况是，代码已经写成了这样了，我更倾向于方式1，因为那样对我原有的代码改动最小，只用将task2提交到另一个线程池就可以了，而且我们硬件资源也是足够的。如果采用方式2，改动比较大。

示例代码

这种情况是与语言无关的，我的主语言是java，所以使用java代码写一个示例，让java道友有更深刻的认识。

使用了hutool工具类和lombok，


		<!--Lombok,需装lombok插件-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>compile</scope>
        </dependency>

java 代码

import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Author: liang.qin
 * @Date: 2023/2/27 19:28
 * @Email: <a href="mailto:liang.qin.work@foxmail.com">liang.qin</a>
 * @Description: 线程池执行父子任务造成死锁
 **/
public class ThreadPoolDeadlockTest1 {


    static int corePoolSize = 4;
    static int maxPoolSize = 6;
    static int keepAliveSeconds = 10;
    static int queueCapacity = 100;
    static String pollName = "excel-dispose";

    static ExecutorService executor = new ThreadPoolExecutor(corePoolSize, maxPoolSize, keepAliveSeconds, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(queueCapacity),
            r -> {
                final AtomicInteger threadNumber = new AtomicInteger(1);
                Thread t = new Thread(r, pollName + "-t-" + threadNumber.getAndIncrement());
                if (t.isDaemon()) {
                    t.setDaemon(false);
                }
                if (t.getPriority() != Thread.NORM_PRIORITY) {
                    t.setPriority(Thread.NORM_PRIORITY);
                }
                return t;
            },
            new ThreadPoolExecutor.CallerRunsPolicy());


    public static void main(String[] args) {
        // 模拟学生excel
        List<Stu> stus = new ArrayList<Stu>() {{
            add(new Stu("1", "张三", 18));
            add(new Stu("2", "李四", 19));
            add(new Stu("3", "王五", 20));
            add(new Stu("4", "赵六", 21));
            add(new Stu("5", "田七", 22));
        }};
        // 模拟学生信息excel
        List<StuInfo> stuInfos = new ArrayList<StuInfo>() {{
            add(new StuInfo("1", "1", "四川xxx"));
            add(new StuInfo("2", "2", "重庆xxx"));
            add(new StuInfo("3", "3", "贵州xxx"));
            add(new StuInfo("4", "4", "云南xxx"));
            add(new StuInfo("5", "5", "甘肃xxx"));
        }};
        // 模拟详细住址excel
        List<AddInfo> addInfos = new ArrayList<AddInfo>() {{
            add(new AddInfo("1", "1", "四川"));
            add(new AddInfo("2", "2", "重庆"));
            add(new AddInfo("3", "3", "贵州"));
            add(new AddInfo("4", "4", "云南"));
            add(new AddInfo("5", "5", "甘肃"));
        }};

        disposeExcel(stus, stuInfos, addInfos);
    }


    /**
     * 处理excel
     *
     * @param stus     学生excel
     * @param stuInfos 学生信息excel
     * @param addInfos 详细地址excel
     */
    public static void disposeExcel(List<Stu> stus, List<StuInfo> stuInfos, List<AddInfo> addInfos) {

        try {
            // 多线程每批处理多少行
            int batchSize = 2;
            // 使用CompletableFuture进行编排
            int total = stus.size() % batchSize == 0 ? stus.size() / batchSize : stus.size() / batchSize + 1;
            CompletableFuture[] futures = new CompletableFuture[total];
            for (int i = 0; i < total; i++) {
                // 开始行数
                int start = batchSize * i;
                // 末尾行数
                int end = (total - 1) == i ? stus.size()-1  : start + batchSize-1;
                futures[i] = CompletableFuture.runAsync(() -> {
                    try {
                        task1(stus, stuInfos, addInfos, start, end);
                    } catch (ExecutionException | InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }, executor);
            }
            // 等待上面的线程都执行完
            CompletableFuture.allOf(futures).get();
        } catch (Exception e) {
            //    进行回滚
            System.out.println();
        }finally {
            executor.shutdown();
        }

    }


    /**
     * 任务1，使用线程池对学生excel和学生信息excel进行处理
     *
     * @param stus     学生excel
     * @param stuInfos 学生信息excel
     * @param addInfos 详细住址excel
     * @param start    需要处理的开始行
     * @param end      需要处理的末尾行
     */
    public static void task1(List<Stu> stus, List<StuInfo> stuInfos, List<AddInfo> addInfos, int start, int end) throws ExecutionException, InterruptedException {
        System.out.println(StrUtil.format("开始处理学生信息{}-{}行",start,end));
        // 循环处理学生excel
        ArrayList<Student> students = new ArrayList<>();
        for (int i = start; i <= end; i++) {
            Stu stu = stus.get(i);
            Student student = new Student();
            student.setId(IdUtil.simpleUUID());
            student.setName(stu.getName());
            student.setAge(stu.getAge());
            students.add(student);
            // 遍历学生信息excel
            for (StuInfo stuInfo : stuInfos) {
                if (stu.getId().equals(stuInfo.getStuId())) {
                    student.setAdd(stuInfo.getAdd());
                    AddInfo addInfo = task2(addInfos, stuInfo.getId());
                    student.setProvince(addInfo.getProvince());
                    break;
                }
            }
        }
        //     入库处理
        // System.out.println(StrUtil.format("完成学生信息{}-{}行入库",start,end));
        for (Student student : students) {
            System.out.println("入库数据："+student);
        }

    }


    /**
     * 任务2，使用线程池，根据唯一的学生信息ID，去查找住址信息
     *
     * @param addInfos  住址信息excel
     * @param stuInfoId 学生信息excel
     * @return 找到的学生信息
     */
    public static AddInfo task2(List<AddInfo> addInfos, String stuInfoId) throws ExecutionException, InterruptedException {
        List<AddInfo> addInfoTemp = Collections.synchronizedList(new ArrayList<>());
        // 多线程每批处理多少行
        int batchSize = 2;
        // 使用CompletableFuture进行编排
        int total = addInfos.size() % batchSize == 0 ? addInfos.size() / batchSize : addInfos.size() / batchSize + 1;
        CompletableFuture[] futures = new CompletableFuture[total];
        for (int i = 0; i < total; i++) {
            // 开始行数
            int start = batchSize * i;
            // 末尾行数
            int end = (total - 1) == i ? addInfos.size() - 1 : start + batchSize;
            futures[i] = CompletableFuture.runAsync(() -> {
                for (int j = start; j <= end; j++) {
                    AddInfo addInfo = addInfos.get(j);
                    if (addInfo.getStuInfoId().equals(stuInfoId)) {
                        addInfoTemp.add(addInfo);
                    }
                }
            }, executor);
        }
        // 等待上面的线程都执行完
        CompletableFuture.allOf(futures).get();
        return addInfoTemp.get(0);
    }


    // 学生
    @Data
    @AllArgsConstructor
    static class Stu {
        private String id;
        private String name;
        private Integer age;
    }


    // 学习信息
    @Data
    @AllArgsConstructor
    static class StuInfo {
        private String id;
        private String stuId;
        private String add;
    }


    // 详细住址
    @Data
    @AllArgsConstructor
    static class AddInfo {
        private String id;
        private String stuInfoId;
        private String province;
    }

    // 拼接成的完整信息
    @Data
    static class Student {
        private String id;
        private String name;
        private Integer age;
        private String add;
        private String province;

        @Override
        public String toString() {
            return JSONUtil.toJsonStr(this);
        }
    }


}

运行主方法，能正常运行并且打印
正常运行的结果

但是一旦将corePoolSize这个参数调整为小于4，或者将stus这个集合中多添加两条实例数据，或者将disposeExcel方法中的batchSize参数设置成1，都会造成死锁。根本原因就是：父任务task1，将线程池中所有的线程都给占用了，子任务task2无线程可用 ，而父任务的结束有依赖于子任务的返回

补充

趁着有空,系统的学习了一下线程池相关的知识,这个现象被称为: 线程池饥饿. 这里有更加详细的视频解释和更加简单的例子: 1.线程池饥饿现象 , 2.饥饿现象解决

但是视频给出的解决方案只有我上面解决方案中的方案1
阿亮_1024
关注
专栏目录
线程池中的父子任务探险记：揭秘陷阱与C#实战
java专栏
07-22 427
通过这次深入探险，你已经掌握了如何在C#中巧妙管理线程池中的父子任务，避开了同步陷阱，实现了高效而安全的并发执行。记住，线程池的管理是一门艺术，平衡与策略至关重要。现在，你已是一名熟练驾驭线程池的高手，继续在编程的宇宙中探索无限可能吧！🌟🌌。
Java线程池 ThreadPoolExecutor 业务线程池
岸河世界
12-31 1766
1.什么是业务线程池？ 在业务开发中，用来处理业务的线程池。 2.为什么需要业务线程池？ 大多数同学都是做业务开发的，很多业务的操作并非要求一定是同步的。例如，对于一系列连续的业务逻辑处理，很多都是数据的组装，拼接，查询，或者将数据同步给各个下层业务（对事务性没有严格要求）；或者对数据的批量操作；这些都可以是异步的。通常业务项目使用的都是的servlet框架，都是使用一个线程进行业务逻辑处理，这种模型是通用的，但不一定是最佳的，不一定是最适合的。需要我们业务开发者根据实际的业务场景去灵活应用，达到最快的响.
Java故障案例分析第一期：父子任务使用不当线程池死锁
2301_79125642的博客
01-31 390
水羊国际，是水羊旗下国际美妆开放平台，全球美妆CP模式开创者，以数字化技术为驱动，为海外合作伙伴在中国全要素、全渠道、全生命周期的持续发展提供全套解决方案。2024-01-31：用go语言，机器人正在玩一个古老的基于DOS的游戏，游戏中有N+1座建筑，从0到N编号，从左到右排列，编号为0的建筑高度为0个单位，编号为。-offer类型：校招-个人情况：bg本九，硕c9，通信专业-offer比较：1.中国移动辽宁省公司：（1）技术类工作，应届入职轮岗1年至1年半，轮岗期间税前工。郑州国企招聘前端开发工程师。
线程池运用不当的一次线上事故
架构师小秘圈
03-09 353
来自：IT人的职场进阶在高并发、异步化等场景，线程池的运用可以说无处不在。线程池从本质上来讲，即通过空间换取时间，因为线程的创建和销毁都是要消耗资源和时间的，对于大量使用线程的场景，使用...
线上问题——2021-12-27 父子线程共用线程池导致死锁故障
夜勿语的博客
03-03 458
从早上6点开始edu-wings-admin的timer-task和mq就开始报警任务堆积，且数量持续上升，到6点50左右mq也开始告警，8点左右发现问题，开始排查，直到11点才找到问题，任务开始正常消费。
父子线程都放在一个线程池会有什么问题
weixin_45614626的博客
05-04 1410
记得之前面试的时候被问到一个问题，如果把父线程和子线程都放在同一个线程池会有什么问题？这个问题没百度到，今天就自己试了试，记录一下。 1.父线程是在线程池提交执行，子线程是通过new Thread创建，这样其实子线程是不会占用线程池的线程数量的，所以对线程池无影响。 import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicInteger; /** * Created by liu shuangzeng on 2017
细数线程池五大坑，一不小心线上就崩了
qq_41466892的博客
11-04 387
系统性能优化的几种常用手段是异步和缓存。因此我们常常使用线程池异步处理一些业务。 线程池的使用还是相对比较简单的，首先创建一个线程池，然后通过execute或submit执行任务。 但魔鬼往往藏于细节之中，稍有不慎就会出错。本文将会详细总结线程池容易出错的五大坑 一、拒绝策略参数知多少 二、拒绝策略使用不当，系统阻塞不可用 三、多任务get()异常时,结果获取有误 四、ThreadLocal与线程池搭配使用，上下文缺失 五、父子任务共用同一线程池，系统“饥饿”死锁 以下为线程池的核心流程【具体内
线程、线程池和ThreadLocal
qq_41421480的博客
08-03 1010
什么是线程安全？（将自己的理解） （一）为什么会有线程安全问题？ 当多个线程同时共享同一个全局变量或静态变量，做写的操作时，可能会发生数据冲突问题，也就是线程安全问题。但是做读的操作不会发生线程安全问题。 （二）如何解决多线程之间线程安全问题？ 使用多线程之间同步synchronized或使用锁（lock），将可能会发生数据冲突问题（线程不安全问题），只能让当前一个线程进行执行。代码执行完成后释放...
线程池newFixedThreadPool父子任务导致的线程死锁问题
二祥的工作历程
07-04 1444
代码 先来看这么一段代码 判断一下是否有问题？ public class ThreadPoolLock { /** * 固定大小为2的线程池 */ private static ExecutorService pool = Executors.newFixedThreadPool(2); /** * 测试 * 开了十个父任务 */ public static void main(String[] args) {
线程池遇到父子任务，有大坑，要注意！
最新发布
IT界那些事儿
07-15 122
最近在使用线程池的时候踩了一个坑，给你分享一下。在实际业务场景下，涉及到业务代码和不同的微服务，导致问题有点难以定位，但是最终分析出原因之后，发现可以用一个很简单的例子来演示。所以这次先用 Demo 说问题，再说场景，方便吸收。
[Java并发编程实战] 线程池的使用之饥饿死锁的发生
seaicelin的博客
06-26 1622
一屋不扫何以扫天下?———《后汉书·陈蕃传》 这句话的意思是，从一点一滴的小事开始积累，才能做成一番大事业。 Executor框架核心之一就是利用线程池，所以接下来这几篇，详细介绍线程池相关的高级选项以及注意事项。 任务间隐性耦合的说明 虽说 Exectuor 将任务和执行策略解耦，但是实际上言过其实了。假如任务之间存在某种相互依赖关系，其中一个任务必须依赖另外一个的执行，这就...
多线程——同步嵌套造成死锁问题
u012369385的专栏
08-20 3869
package com.qianfeng.demo02; /** * 同步的另外一个弊端：死锁 * * 最常见的死锁的情况： * 同步嵌套，同步中还有同步，然后两个同步用的不是一把锁。 * * 不是使用死锁，而是避免死锁。 * * 尽量避免同步嵌套的情况。 * */ public class DeadLockDemo01 { public static void mai
Java核心编程总结(五、线程池与死锁)
Augenstern_QXL的博客
04-27 1812
1.基础回顾+面试 1.1线程池 什么是线程池？ 答：线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复的使用，省去了频繁创建和销毁线程对象的操作，无需反复创建线程而消耗过多资源 为什么要用线程池？ 答： 降低资源消耗，减少了创建和销毁线程的次数 提高响应速度，不需要频繁的创建线程 提高线程的可管理性（线程池可以约束系统最多只能有多少个线程，不会因为线程过多而死机) 1.2创建线程池 线程池在Java中的代表类：ExecutorService(接口) new FixedThr
线程池死锁
weixin_30252155的博客
04-18 1382
使用线程池的风险 死锁：虽然死锁可能发生在任何多线程程序中，但线程池引入了另一种死锁情况，其中所有正在执行的线程都在等待等待队列阻塞线程的结果，因为执行的线程不可用。 简言之：业务线程在占用了线程池内所有的资源后又向线程池提交了新的任务，并且要等这些任务完成后才释放资源，而这些新提交的任务根本就没机会被完成 线程泄漏：如果从池中删除线程以执行任务但在任务完成时未返回线程，则会发生线程泄漏。例...
线程池引发的生产的事故
flymoringbird的博客
10-13 189
故障的结果： 响应很慢，乃至超时？ 查询日志： 所有的请求都已经正确执行了，但是仍然有很多接口响应较慢； 初步分析原因： 网络，数据库，nginx，ingress 日志详细查询原因： jetty 的线程池打满。 线程池打满代码分析原因： 代码中的线程池：设置如下 @Bean("xxxExecutor") public Executor taskExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecut.
线程池的死锁事件
scwMason的博客
07-23 1223
线程池的死锁问题
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值