动态线程池

原创 于 2025-07-22 17:35:50 发布 · 291 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #后端

在这里插入图片描述

此项目是已组件的形式进行搭建
分为 4 个部分 config、domain、registry、trigger

  • config：自动装配 Bean，获取项目中的线程池，创建 redis 消息中心
  • domain：存储线程池的 Bean，修改线程池
  • registry：redis 注册中心，将线程池的信息上传到 redis
  • trigger：
    • job：定时任务，将线程池信息上传到 redis 中
    • listener：订阅 redis 注册中心，等待注册中心推送消息，然后根据消息修改线程池，再将线程池配置信息上传到 redis 中

domain

public class ThreadPoolConfigEntity {

    /**
     * 应用名称
     */
    private String appName;

    /**
     * 线程池名称
     */
    private String threadPoolName;

    /**
     * 核心线程数
     */
    private int corePoolSize;

    /**
     * 最大线程数
     */
    private int maximumPoolSize;

    /**
     * 当前活跃线程数
     */
    private int activeCount;

    /**
     * 当前池中线程数
     */
    private int poolSize;

    /**
     * 队列类型
     */
    private String queueType;

    /**
     * 当前队列任务数
     */
    private int queueSize;

    /**
     * 队列剩余任务数
     */
    private int remainingCapacity;

    public ThreadPoolConfigEntity() {
    }

    public ThreadPoolConfigEntity(String appName, String threadPoolName) {
        this.appName = appName;
        this.threadPoolName = threadPoolName;
    }
}

线程池的配置信息，要存储在 redis 中

public interface IDynamicThreadPoolService {

    List<ThreadPoolConfigEntity> queryThreadPoolList();

    ThreadPoolConfigEntity queryThreadPoolConfigByName(String threadPoolName);

    void updateThreadPoolConfig(ThreadPoolConfigEntity threadPoolConfigEntity);
}

动态线程服务池接口

public class DynamicThreadPoolService implements IDynamicThreadPoolService {

    private final Logger logger = LoggerFactory.getLogger(DynamicThreadPoolService.class);

    private final String applicationName;
    private final Map<String, ThreadPoolExecutor> threadPoolExecutorMap;

    public DynamicThreadPoolService(String applicationName, Map<String, ThreadPoolExecutor> threadPoolMap) {
        this.applicationName = applicationName;
        this.threadPoolExecutorMap = threadPoolMap;
    }


    @Override
    public List<ThreadPoolConfigEntity> queryThreadPoolList() {
        Set<String> threadPoolBeanNames = threadPoolExecutorMap.keySet();
        List<ThreadPoolConfigEntity> threadPoolVOS = new ArrayList<>(threadPoolBeanNames.size());
        for (String beanName : threadPoolBeanNames) {
            ThreadPoolExecutor threadPoolExecutor = threadPoolExecutorMap.get(beanName);
            ThreadPoolConfigEntity threadPoolConfigVO = new ThreadPoolConfigEntity(applicationName, beanName);
            threadPoolConfigVO.setCorePoolSize(threadPoolExecutor.getCorePoolSize());
            threadPoolConfigVO.setMaximumPoolSize(threadPoolExecutor.getMaximumPoolSize());
            threadPoolConfigVO.setActiveCount(threadPoolExecutor.getActiveCount());
            threadPoolConfigVO.setPoolSize(threadPoolExecutor.getPoolSize());
            threadPoolConfigVO.setQueueType(threadPoolExecutor.getQueue().getClass().getSimpleName());
            threadPoolConfigVO.setQueueSize(threadPoolExecutor.getQueue().size());
            threadPoolConfigVO.setRemainingCapacity(threadPoolExecutor.getQueue().remainingCapacity());
            threadPoolVOS.add(threadPoolConfigVO);
        }
        return threadPoolVOS;
    }

    @Override
    public ThreadPoolConfigEntity queryThreadPoolConfigByName(String threadPoolName) {
        ThreadPoolExecutor threadPoolExecutor = threadPoolExecutorMap.get(threadPoolName);
        if (null == threadPoolExecutor) return new ThreadPoolConfigEntity(applicationName, threadPoolName);

        // 线程池配置数据
        ThreadPoolConfigEntity threadPoolConfigVO = new ThreadPoolConfigEntity(applicationName, threadPoolName);
        threadPoolConfigVO.setCorePoolSize(threadPoolExecutor.getCorePoolSize());
        threadPoolConfigVO.setMaximumPoolSize(threadPoolExecutor.getMaximumPoolSize());
        threadPoolConfigVO.setActiveCount(threadPoolExecutor.getActiveCount());
        threadPoolConfigVO.setPoolSize(threadPoolExecutor.getPoolSize());
        threadPoolConfigVO.setQueueType(threadPoolExecutor.getQueue().getClass().getSimpleName());
        threadPoolConfigVO.setQueueSize(threadPoolExecutor.getQueue().size());
        threadPoolConfigVO.setRemainingCapacity(threadPoolExecutor.getQueue().remainingCapacity());

        if (logger.isDebugEnabled()) {
            logger.info("动态线程池，配置查询 应用名:{} 线程名:{} 池化配置:{}", applicationName, threadPoolName, JSON.toJSONString(threadPoolConfigVO));
        }

        return threadPoolConfigVO;
    }

    @Override
    public void updateThreadPoolConfig(ThreadPoolConfigEntity threadPoolConfigEntity) {
        if (threadPoolConfigEntity ==  null || !applicationName.equals(threadPoolConfigEntity.getAppName())) {
            return;
        }
        ThreadPoolExecutor threadPoolExecutor = threadPoolExecutorMap.get(threadPoolConfigEntity.getThreadPoolName());
        if (null == threadPoolExecutor) {
            return;
        }

        threadPoolExecutor.setMaximumPoolSize(threadPoolConfigEntity.getMaximumPoolSize());
        threadPoolExecutor.setCorePoolSize(threadPoolConfigEntity.getCorePoolSize());
        logger.info("更新线程池 {} 的配置信息", JSON.toJSONString(threadPoolExecutor));
    }
}

线程池服务，获取线程池配置信息、更改线程配置

registry

public interface IRegistry {

    void reportThreadPool(List<ThreadPoolConfigEntity> threadPoolEntities);

    void reportThreadPoolConfigParameter(ThreadPoolConfigEntity threadPoolConfigEntity);

}

注册中心，数据上报，可以使用 redis、MySQL 等实现

public class RedisRegistry implements IRegistry {

    private final RedissonClient redissonClient;


    public RedisRegistry(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    // 上报数据
    @Override
    public void reportThreadPool(List<ThreadPoolConfigEntity> threadPoolEntities) {
        RList<ThreadPoolConfigEntity> list = redissonClient.getList(RegistryEnumVO.THREAD_POOL_CONFIG_LIST_KEY.getKey());
        list.addAll(threadPoolEntities);
    }

    @Override
    public void reportThreadPoolConfigParameter(ThreadPoolConfigEntity threadPoolConfigEntity) {
        String strKey = RegistryEnumVO.THREAD_POOL_CONFIG_PARAMETER_LIST_KEY.getKey() + "_" + threadPoolConfigEntity.getAppName() + "_" + threadPoolConfigEntity.getThreadPoolName();
        RBucket<ThreadPoolConfigEntity> bucket = redissonClient.getBucket(strKey);
        bucket.set(threadPoolConfigEntity, Duration.ofDays(30));
    }

}

trigger

job

public class ThreadPoolDataReportJob {

    private final Logger logger = LoggerFactory.getLogger(ThreadPoolDataReportJob.class);

    private final RedisRegistry redisRegistry;
    private final DynamicThreadPoolService dynamicThreadPoolService;

    public ThreadPoolDataReportJob(RedisRegistry redisRegistry, DynamicThreadPoolService dynamicThreadPoolService) {
        this.redisRegistry = redisRegistry;
        this.dynamicThreadPoolService = dynamicThreadPoolService;
    }

    @Scheduled(cron = "*/20 * * * * *")
    public void execReportThreadPoolList() {
        List<ThreadPoolConfigEntity> threadPoolConfigEntities = dynamicThreadPoolService.queryThreadPoolList();
        redisRegistry.reportThreadPool(threadPoolConfigEntities);
        logger.info("上部线程池数据, {}", JSON.toJSONString(threadPoolConfigEntities));

        for (ThreadPoolConfigEntity threadPoolConfigEntity : threadPoolConfigEntities) {
            redisRegistry.reportThreadPoolConfigParameter(threadPoolConfigEntity);
            logger.info("上报线程池的配置信息, {}", JSON.toJSONString(threadPoolConfigEntity));
        }

    }
}

定时将线程池信息上传到 redis 中

public class ThreadPoolDataReportJob {

    private final Logger logger = LoggerFactory.getLogger(ThreadPoolDataReportJob.class);

    private final RedisRegistry redisRegistry;
    private final DynamicThreadPoolService dynamicThreadPoolService;

    public ThreadPoolDataReportJob(RedisRegistry redisRegistry, DynamicThreadPoolService dynamicThreadPoolService) {
        this.redisRegistry = redisRegistry;
        this.dynamicThreadPoolService = dynamicThreadPoolService;
    }

    @Scheduled(cron = "*/20 * * * * *")
    public void execReportThreadPoolList() {
        List<ThreadPoolConfigEntity> threadPoolConfigEntities = dynamicThreadPoolService.queryThreadPoolList();
        redisRegistry.reportThreadPool(threadPoolConfigEntities);
        logger.info("上部线程池数据, {}", JSON.toJSONString(threadPoolConfigEntities));

        for (ThreadPoolConfigEntity threadPoolConfigEntity : threadPoolConfigEntities) {
            redisRegistry.reportThreadPoolConfigParameter(threadPoolConfigEntity);
            logger.info("上报线程池的配置信息, {}", JSON.toJSONString(threadPoolConfigEntity));
        }
    }
}

listener

public class ThreadPoolConfigAdjustListener implements MessageListener<ThreadPoolConfigEntity> {

    private final Logger logger = LoggerFactory.getLogger(ThreadPoolConfigAdjustListener.class);

    private final RedisRegistry redisRegistry;
    private final DynamicThreadPoolService dynamicThreadPoolService;

    public ThreadPoolConfigAdjustListener(RedisRegistry redisRegistry, DynamicThreadPoolService dynamicThreadPoolService) {
        this.dynamicThreadPoolService = dynamicThreadPoolService;
        this.redisRegistry = redisRegistry;
    }


    @Override
    public void onMessage(CharSequence charSequence, ThreadPoolConfigEntity threadPoolConfigEntity) {
        logger.info("动态线程池，调整线程池配置。线程池名称:{} 核心线程数:{} 最大线程数:{}",
                threadPoolConfigEntity.getThreadPoolName(), threadPoolConfigEntity.getPoolSize(), threadPoolConfigEntity.getMaximumPoolSize());

        dynamicThreadPoolService.updateThreadPoolConfig(threadPoolConfigEntity);

        List<ThreadPoolConfigEntity> threadPoolConfigEntities = dynamicThreadPoolService.queryThreadPoolList();
        redisRegistry.reportThreadPool(threadPoolConfigEntities);

        ThreadPoolConfigEntity poolConfigEntity = dynamicThreadPoolService.queryThreadPoolConfigByName(threadPoolConfigEntity.getThreadPoolName());
        redisRegistry.reportThreadPoolConfigParameter(poolConfigEntity);

    }
}

使用 redis 中的消息队列订阅消息，当腰更改线程池配置时，会发送一个消息，此监听者会接收到消息然后进行更改

config

@Configuration
// 如果不添加这个 DynamicThreadPoolAutoProperties 会报错
@EnableConfigurationProperties(DynamicThreadPoolAutoProperties.class)
// 开启定时任务
@EnableScheduling
public class DynamicThreadPoolAutoConfig {

    private final Logger logger = LoggerFactory.getLogger(DynamicThreadPoolAutoConfig.class);
    private String applicationName;
    @Bean
    public DynamicThreadPoolService dynamicThreadPoolNameService(ApplicationContext applicationContext, Map<String, ThreadPoolExecutor> stringThreadPoolExecutorMap, RedissonClient redissonClient) {

        this.applicationName = applicationContext.getEnvironment().getProperty("spring.application.name");
        logger.info(applicationName);

        // 获取缓存数据，设置本地线程池配置
        Set<String> threadPoolKeys = stringThreadPoolExecutorMap.keySet();
        for (String threadPoolKey : threadPoolKeys) {
            ThreadPoolConfigEntity threadPoolConfigEntity = redissonClient.<ThreadPoolConfigEntity>getBucket(RegistryEnumVO.THREAD_POOL_CONFIG_PARAMETER_LIST_KEY.getKey() + "_" + applicationName + "_" + threadPoolKey).get();
            if (null == threadPoolConfigEntity) continue;
            ThreadPoolExecutor threadPoolExecutor = stringThreadPoolExecutorMap.get(threadPoolKey);
            threadPoolExecutor.setCorePoolSize(threadPoolConfigEntity.getCorePoolSize());
            threadPoolExecutor.setMaximumPoolSize(threadPoolConfigEntity.getMaximumPoolSize());
        }

        logger.info(stringThreadPoolExecutorMap.toString());

        return new DynamicThreadPoolService(applicationName, stringThreadPoolExecutorMap);
    }

    @Bean("redissonClient")
    public RedissonClient redissonClient(DynamicThreadPoolAutoProperties properties) {
        Config config = new Config();
        // 根据需要可以设定编解码器；https://github.com/redisson/redisson/wiki/4.-%E6%95%B0%E6%8D%AE%E5%BA%8F%E5%88%97%E5%8C%96
        config.setCodec(JsonJacksonCodec.INSTANCE);

        config.useSingleServer()
                .setAddress("redis://" + properties.getHost() + ":" + properties.getPort())
                .setPassword(properties.getPassword())
                .setConnectionPoolSize(properties.getPoolSize())
                .setConnectionMinimumIdleSize(properties.getMinIdleSize())
                .setIdleConnectionTimeout(properties.getIdleTimeout())
                .setConnectTimeout(properties.getConnectTimeout())
                .setRetryAttempts(properties.getRetryAttempts())
                .setRetryInterval(properties.getRetryInterval())
                .setPingConnectionInterval(properties.getPingInterval())
                .setKeepAlive(properties.isKeepAlive())
        ;

        RedissonClient redissonClient = Redisson.create(config);



        logger.info("动态线程池，注册器（redis）链接初始化完成。{} {} {}", properties.getHost(), properties.getPoolSize(), !redissonClient.isShutdown());

        return redissonClient;
    }

    @Bean("RedisRegistry")
    public RedisRegistry redisRegistry(RedissonClient redissonClient) {
        return new RedisRegistry(redissonClient);
    }

    @Bean
    public ThreadPoolDataReportJob threadPoolDataReportJob(RedisRegistry redisRegistry, DynamicThreadPoolService dynamicThreadPoolService) {
        return new ThreadPoolDataReportJob(redisRegistry, dynamicThreadPoolService);
    }

    @Bean
    public ThreadPoolConfigAdjustListener threadPoolConfigAdjustListener(RedisRegistry redisRegistry, DynamicThreadPoolService dynamicThreadPoolNameService) {
        return new ThreadPoolConfigAdjustListener(redisRegistry, dynamicThreadPoolNameService);
    }

    @Bean(name = "dynamicThreadPoolRedisTopic")
    public RTopic threadPoolConfigAdjustListener(RedissonClient redissonClient, ThreadPoolConfigAdjustListener threadPoolConfigAdjustListener) {
        RTopic rTopic = redissonClient.getTopic(RegistryEnumVO.DYNAMIC_THREAD_POOL_REDIS_TOPIC + "_" + applicationName);
        rTopic.addListener(ThreadPoolConfigEntity.class, threadPoolConfigAdjustListener);
        return rTopic;
    }
}

注册各种 Bean

    @Bean
    public DynamicThreadPoolService dynamicThreadPoolNameService(ApplicationContext applicationContext, Map<String, ThreadPoolExecutor> stringThreadPoolExecutorMap, RedissonClient redissonClient) {

        this.applicationName = applicationContext.getEnvironment().getProperty("spring.application.name");
        logger.info(applicationName);

        // 获取缓存数据，设置本地线程池配置
        Set<String> threadPoolKeys = stringThreadPoolExecutorMap.keySet();
        for (String threadPoolKey : threadPoolKeys) {
            ThreadPoolConfigEntity threadPoolConfigEntity = redissonClient.<ThreadPoolConfigEntity>getBucket(RegistryEnumVO.THREAD_POOL_CONFIG_PARAMETER_LIST_KEY.getKey() + "_" + applicationName + "_" + threadPoolKey).get();
            if (null == threadPoolConfigEntity) continue;
            ThreadPoolExecutor threadPoolExecutor = stringThreadPoolExecutorMap.get(threadPoolKey);
            threadPoolExecutor.setCorePoolSize(threadPoolConfigEntity.getCorePoolSize());
            threadPoolExecutor.setMaximumPoolSize(threadPoolConfigEntity.getMaximumPoolSize());
        }

        logger.info(stringThreadPoolExecutorMap.toString());

        return new DynamicThreadPoolService(applicationName, stringThreadPoolExecutorMap);
    }

当项目引用此组件时，原项目的线程池就会作为参数进入这个方法

【动态线程池】自制轻量级动态线程池
qq_63691275的博客
06-14 1566
在平常在使用线程池进行异步操作的时候，对线程池进行参数配置时，一般就根据当前服务器去计算密集、IO密集公式套算出核心线程数去配置。但项目上线时场景总是多变的，如果核心线程数和最大线程数定死，线程数高了RT可能低了，但是QPS未必会有想要的效果，毕竟服务器的资源就在那里，大量线程涌入无非会导致大量的线程上下文切换（首先得用户态切换内核态，然后保存CPU上下文信息，将调度线程的上下文信息载入进去），这过程也是比较耗时的
实现一个简易动态线程池
m0_63208096的博客
06-20 2540
实现一个简易的动态线程池
【JUC】动态线程池
机智的路易
07-07 726
需求：动态调整参数、细粒度监控、秒级监控线程池参数调优，需要不断的进行测试，判断内存占用等因素，调优没法热部署。
基于C++11 实现的动态线程池源码示例.zip
05-10
基于C++11 实现的动态线程池源码示例.zip 【资源说明】 使用 C++11 实现的动态线程池，主要特性： 使用简单，不易出错。 支持线程复用，提升性能。 支持懒惰创建线程。 必要时自动回收空闲的线程。 【快速上手】 #...
从手动到智能: 动态线程池讲解
我是一名热爱编程和分享知识的技术作者，在金融和教育领域有多年的研发管理经验，感谢您访问我的博客，一定会为您带来不一样的收货！
09-09 1389
在平时的开发中，系统的性能和吞吐量是衡量系统的重要指标，那提高系统性能和吞吐量的方式你知道有哪些吗？减少网络通信：比如能批量通过接口查询的尽量避免多次循环查询减少 IO 操作：比如操作数据库时能批量操作的选择批量操作，减少与数据库的操作使用缓存：将数据缓存起来，减少网络请求等操作数据库建立合适的索引的减少锁的所用使用分布式设计异步编程使用多线程以上列举了一部分，还有其他一些优化技术就不一一列举了，本文的主角是动态线程池，下面详细介绍一下多线程编程。
动态线程池设计与实现
最新发布
weixin_44929475的博客
11-18 1814
动态线程池技术是一种可以根据当前系统负载动态调整线程数量的线程池实现方式。
springboot动态线程池、线程池监控
09-10
Spring Boot的动态线程池功能，使得开发者能够在应用程序运行期间动态地调整线程池的参数，实现更加灵活的资源管理。此外，线程池监控功能则能够帮助开发者及时了解线程池运行状态，便于快速定位和解决问题。 动态...
历时2月，动态线程池 DynamicTp 发布里程碑版本 V1.0.8
https://github.com/lyh200
08-24 594
DynamicTp 是一个基于配置中心实现的轻量级动态线程池管理工具，主要功能可以总结为动态调参、通知报警、运行监控、三方包线程池管理等几大类
【学习】动态线程池
大家一起debug！
04-10 199
采用动态线程池思想，继承ThreadPoolExecutor类，借助其提供的接口，实现平滑修改线程池参数；以及线程执行前后的afterExecute、beforeExcute实现线程池运行监控；进一步扩展：将项目中的线程池的创建和销毁都统一交给线程池管理对象，实现统一管理和监控；调整线程池参数，无法较好的平衡；
动态线程池Dinamic-Tp（基础篇）
我家有个小喵咪
03-19 8852
本文主要讲Dinamic-Tp开源框架的基础知识。DynamicTp项目地址：官网：https://dynamictp.cn/gitee地址：https://gitee.com/dromara/dynamic-tpgithub地址：https://github.com/dromara/dynamic-tp使用线程池 ThreadPoolExecutor 过程中你是否有以下痛点呢？那么使
轻量级动态线程池才是“王道”？
Long-Tai
03-14 1783
大家好，我是龙台。 一、前言 最初设计 Hippo4j 的初衷是尽可能提高以及保障线程池对于线上应用的作用，所以加了很多个性化功能，这也间接导致强依赖 Hippo4j Server 项目。 自 Hippo4j 1.0.0 版本发布之后，不断有社区小伙伴提出相同的一个问题，如何能够轻量级使用动态线程池？ 这不，它来了。 GitHub：https://github.com/acmenlt/dynamic-threadpool Gitee：https://gitee.com/acmenlt/dynamic
动态线程池（四）
qq_41686437的博客
09-20 282
动态线程池 dtp生命周期管理 生命周期相关类图 DtpExecutor EagerEtpExecutor OrderedDtpExecutor TaskWrapper任务包装器 MdcRunnable TaskWrappers NotifyEnum NoticeManager通知管理器 InvokerChain调用链
【ICE】【08】动态线程池
huiyanshizhen21的博客
07-28 384
Dynamic Thread Pools A dynamic thread pool can grow and shrink when necessary in response to changes in an application’s work load. All thread pools have at least one thread, but a dynamic thread pool can grow as the demand for threads increases, up to the
关于动态线程池的实现
weixin_63325479的博客
05-26 605
线程池中有几个核心参数， 核心线程数， 最大线程数， 阻塞队列， 拒绝策略， 备用线程生存时间等等。那是不是有一种方法， 能够通过动态调整线程池的方式， 来实现即时的参数调整，来让线程池更好的适配任务场景， 减少意外发生的风险和损失呢。listener： Thread Pool Config AdjustListener 线程池配置调整监听器： 用于上报线程池信息，和线程池参数信息，及时更新数据展示。创建 service类： 管理线程池： 获取线程池信息，获取线程池配置信息，更新线程池配置。
【项目实战】并发编程之Spring框架中的异步支持，包括`@Async`注解、Spring WebFlux响应式编程以及相关接口和类的使用方法
本本本添哥
08-25 341
是Spring框架中的一个线程池任务执行器。提供了与Spring框架更好的集成和支持。是一个用于管理后台任务执行的工具。允许开发者轻松地创建和管理线程池，用于执行异步任务。工具提供了丰富的配置选项，可以根据应用程序的具体需求进行调整。
分享一款非常强大的动态线程池
weixin_44028058的博客
12-13 881
;分享好玩的项目，挖掘开源的价值。;大家好，我是【开源君】。今天给大家分享的开源项目的是【dynamic-threadpool】
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值