通过配置类定义线程池

已于 2022-10-24 16:28:33 修改
阅读量353 收藏
点赞数
分类专栏： 实操 文章标签： 1024程序员节 java
于 2022-10-24 16:24:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EDT777/article/details/127494632
版权

文章目录

线程工具类

  • ThreadUtil
public class ThreadUtil {

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

    public static void sleepByWait(long timeout) throws InterruptedException {
        byte[] lock = new byte[0];
        synchronized (lock){
            lock.wait(timeout);
        }
        lock = null;
    }


    public static RejectedExecutionHandler blockExecuteRejectHandle(String name){
        return new BlockExecuteRejectHandle(name);
    }

    public static ThreadFactory threadFactory(String name){
        return new TFactory(name);
    }

    static class TFactory implements ThreadFactory {

        private final ThreadGroup group;
        //编号
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        //池子名称
        private final String namePrefix;

        public TFactory(String name) {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                    Thread.currentThread().getThreadGroup();
            namePrefix = name.concat("-");
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                    namePrefix + threadNumber.getAndIncrement(),
                    0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }


    static class BlockExecuteRejectHandle implements RejectedExecutionHandler {

        final String name;

        public BlockExecuteRejectHandle(String name) {
            this.name = name.concat("RejectHandle");
        }

        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                try {
                    logger.warn("{} 阻塞加入 | pool:{}",name,e);
                    e.getQueue().put(r);
                } catch (Exception ex) {
                    logger.error("{} 阻塞加入异常",e,ex);
                }
            }
        }
    }

    /**
     * 每个线程任务需要处理的数据量
     * @param dataSize 数据个数
     * @param maxTaskNum 最多创建多少个线程任务
     * @return  返回<=1  就再当前线程执行    返回其他就在池子中执行
     */
    public static int avgCapacity(int dataSize, int maxTaskNum) {
        int _c = dataSize / maxTaskNum;
        if (_c == 0){
            return 0;//dataSize < maxTaskNum 就不使用线程池执行
        }
        return dataSize % maxTaskNum == 0 ? _c : _c + 1;
    }

    /**
     * 某个大集合切割为多个
     * @param ls 数据集
     * @param fun 需要并发执行的方法
     * @param executor 线程池
     * @param maxTaskNum 此集合最多拆为几个任务
     * @param <T>
     */
    public static <T> void concurrentExecuteAndBlockResult(ThreadPoolExecutor executor, int maxTaskNum,Function<List<T>, Void> fun,List<T> ls){
        if (ls.isEmpty()){
            return;
        }
        int avgCapacity = ThreadUtil.avgCapacity(ls.size(), maxTaskNum);
        if (avgCapacity <= 1){
            fun.apply(ls);
        }else {
            List<List<T>> lists = Lists.partition(ls, avgCapacity);
            CompletableFuture[] all = new CompletableFuture[lists.size()];
            for (int i = 0; i < lists.size(); i++) {
                List<T> tmp = lists.get(i);
                if (tmp.isEmpty()){
                    continue;
                }
                all[i] = CompletableFuture.runAsync(() -> fun.apply(tmp), executor);
            }
            CompletableFuture.allOf(all).join();
        }
    }

    /**
     * 某个大集合切割为多个
     * @param ls 数据集
     * @param fun 需要并发执行的方法
     * @param executor 线程池
     * @param oneTaskDataSize 一个任务多少条数据
     * @param <T>
     */
    public static <T> void concurrentExecuteAndBlockResultVo(ThreadPoolExecutor executor, int oneTaskDataSize,Function<List<T>, Void> fun,List<T> ls){
        if (ls.isEmpty()){
            return;
        }
        if (ls.size() <= oneTaskDataSize){
            fun.apply(ls);
        }else {
            List<List<T>> lists = Lists.partition(ls, oneTaskDataSize);
            CompletableFuture[] all = new CompletableFuture[lists.size()];
            for (int i = 0; i < lists.size(); i++) {
                List<T> tmp = lists.get(i);
                if (tmp.isEmpty()){
                    continue;
                }
                all[i] = CompletableFuture.runAsync(() -> fun.apply(tmp), executor);
            }
            CompletableFuture.allOf(all).join();
        }
    }


    /**
     * 某个大集合切割为多个
     * @param ls 数据集
     * @param fun 需要并发执行的方法
     * @param executor 线程池
     * @param oneTaskDataSize 一个任务多少条数据
     * @param <T>
     */
    public static <T> void concurrentExecuteAndBlockResultVoForAbortPolicyReject(ThreadPoolExecutor executor, int oneTaskDataSize, Function<List<T>, Void> fun, List<T> ls){
        if (ls.isEmpty()){
            return;
        }
        if (ls.size() <= oneTaskDataSize){
            fun.apply(ls);
        }else {
            List<List<T>> lists = Lists.partition(ls, oneTaskDataSize);
            CompletableFuture[] all = new CompletableFuture[lists.size()];
            for (int i = 0; i < lists.size(); i++) {
                List<T> tmp = lists.get(i);
                if (tmp.isEmpty()){
                    continue;
                }
                int reNum = 0;
                while (all[i] == null){
                    try {
                        all[i] = CompletableFuture.runAsync(() -> fun.apply(tmp), executor);
                    } catch (RejectedExecutionException e) {
                        if (reNum == 0){
                            logger.warn("线程池处理任务繁忙:{}",e.getMessage());
                        }
                        reNum++;
                        try {Thread.sleep(3);} catch (Exception e1) {}
                    }catch (Exception e){
                        logger.error("线程池处理任务异常",e);
                        break;
                    }
                }

                if (reNum>0){
                    logger.warn("线程池处理任务繁忙 重试次数:{}",reNum);
                }
            }
            CompletableFuture.allOf(all).join();
        }
    }

    /**
     * 某个大集合切割为多个
     * @param ls 数据集
     * @param fun 需要并发执行的方法
     * @param executor 线程池
     * @param maxTaskNum 此集合最多拆为几个任务
     * @param <T>
     */
    public static <T> void concurrentExecuteAndBlockResult(ThreadPoolExecutor executor, int maxTaskNum,BiFunction<List<T>, Object, Void> fun, List<T> ls,Object p0){
        if (ls.isEmpty()){
            return;
        }
        int avgCapacity = ThreadUtil.avgCapacity(ls.size(), maxTaskNum);
        if (avgCapacity <= 1){
            fun.apply(ls,p0);
        }else {
            List<List<T>> lists = Lists.partition(ls, avgCapacity);
            CompletableFuture[] all = new CompletableFuture[lists.size()];
            for (int i = 0; i < lists.size(); i++) {
                List<T> tmp = lists.get(i);
                if (tmp.isEmpty()){
                    continue;
                }
                all[i] = CompletableFuture.runAsync(() -> fun.apply(tmp,p0), executor);
            }
            CompletableFuture.allOf(all).join();
        }
    }

    /**
     * 某个大集合切割为多个
     * @param ls 数据集
     * @param fun 需要并发执行的方法
     * @param executor 线程池
     * @param maxTaskNum 此集合最多拆为几个任务
     * @param <T>
     */
    public static <T> void concurrentExecuteAndBlockResult(ThreadPoolExecutor executor, int maxTaskNum,BiFunction<List<T>, Object[], Void> fun, List<T> ls,Object... oArr){
        if (ls.isEmpty()){
            return;
        }
        int avgCapacity = ThreadUtil.avgCapacity(ls.size(), maxTaskNum);
        if (avgCapacity <= 1){
            fun.apply(ls,oArr);
        }else {
            List<List<T>> lists = Lists.partition(ls, avgCapacity);
            CompletableFuture[] all = new CompletableFuture[lists.size()];
            for (int i = 0; i < lists.size(); i++) {
                List<T> tmp = lists.get(i);
                if (tmp.isEmpty()){
                    continue;
                }
                all[i] = CompletableFuture.runAsync(() -> fun.apply(tmp,oArr), executor);
            }
            CompletableFuture.allOf(all).join();
        }
    }



    public static <T,R> List<R> exec(ThreadPoolExecutor executor, int maxTaskNum,
                                     Function<List<T>, List<R>> fun,
                                     List<T> dataLs){
        if (dataLs.isEmpty()){
            return new ArrayList<>();
        }
        int avgCapacity = avgCapacity(dataLs.size(), maxTaskNum);
        if (avgCapacity <= 1){
            return fun.apply(dataLs);
        }else {
            List<R> ret = new CopyOnWriteArrayList<>();
            List<List<T>> lists = Lists.partition(dataLs, avgCapacity);
            CompletableFuture<? extends List<? extends R>>[] all = new CompletableFuture[lists.size()];
            for (int i = 0; i < lists.size(); i++) {
                List<T> tmp = lists.get(i);
                if (tmp.isEmpty()){
                    continue;
                }
                all[i] = CompletableFuture.supplyAsync(() -> fun.apply(tmp), executor).whenCompleteAsync((rv, ex) -> {
                    if (ex != null) {
                        ex.printStackTrace();
                    }
                    if (rv != null) {
                        ret.addAll(rv);
                    }
                });
            }
            CompletableFuture.allOf(all).join();
            return ret;
        }
    }

}

yml配置文件定义线程池参数

# 业务线程池配置
business-thread-pools:
  # 国内短信
  sms:
    # 从各个网关采集状态报告线程池，建议值为网关的个数
    collect-report-pool:
      pool-core-size: 2

线程池配置类(供参考)


import com.xyc.sms.common.util.ThreadUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Configuration
public class BusinessThreadPoolConfig {

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

    /**
     * 引用外部yml配置文件参数(外部没配置参数就用`PoolConfig`自定义默认的参数)
     */
    @Bean(name = "collectReportPoolConfig")
    @ConfigurationProperties(prefix = "business-thread-pools.sms.collect-report-pool")
    public PoolConfig collectReportPoolConfig(){
        return new PoolConfig("CollectReportPool");
    }


    /**
     * 不引用外部Yml配置参数的写法(线程池参数在`PoolConfig`类里面自己写死)
     */
    @Bean(name = "queueConfig")
    public PoolConfig queueTransferSqlConfig() {
        return new PoolConfig("QueueTransferSql");
    }


    /**
     * 拒绝策略使用等待队列的线程池配置
     */
    @Bean(name = "timToQueueThreadPool")
    public ThreadPoolExecutor timToQueueThreadPool(@Qualifier("queueConfig") PoolConfig c) {
        //打印参数日志
        PoolConfig useConfig = c.printInitInfoAndReturnUse(true);
        return new ThreadPoolExecutor(useConfig.getPoolCoreSize(), useConfig.getPoolMaxSize(), 60, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(),
                ThreadUtil.threadFactory(useConfig.getPoolNamPrefix()),
                new ThreadPoolExecutor.CallerRunsPolicy());
    }


    /**
     * 采集状态报告 线程池
     */
    @Bean(name = "collectReportPool")
    public ThreadPoolExecutor collectReportPool(@Qualifier("collectReportPoolConfig") PoolConfig c){
        PoolConfig useConfig = c.printInitInfoAndReturnUse(true);//打印参数日志
        return new ThreadPoolExecutor(useConfig.getPoolCoreSize(),useConfig.getPoolMaxSize(),0, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(),
                ThreadUtil.threadFactory(useConfig.getPoolNamPrefix()),
                ThreadUtil.blockExecuteRejectHandle(useConfig.getPoolNamPrefix()));
    }



    /**
     * 线程池配置类
     */
    private class PoolConfig {

        private int poolCoreSize = -1;
        private int poolMaxSize = -1;
        private int taskQueueMaxSize = -1;
        private String poolNamPrefix;

        //不配置使用的默认值  ps：如果不配置 yml
        private int poolCoreSize_default = 1;
        private int poolMaxSize_default = 2;
        private int taskQueueMaxSize_default = 1;

        public PoolConfig(String poolNamPrefix) {
            this.poolNamPrefix = poolNamPrefix;
        }

        public int getPoolCoreSize() {
            return poolCoreSize;
        }

        public void setPoolCoreSize(int poolCoreSize) {
            this.poolCoreSize = poolCoreSize;
        }

        public int getPoolMaxSize() {
            return poolMaxSize;
        }

        public void setPoolMaxSize(int poolMaxSize) {
            this.poolMaxSize = poolMaxSize;
        }

        public int getTaskQueueMaxSize() {
            return taskQueueMaxSize;
        }

        public void setTaskQueueMaxSize(int taskQueueMaxSize) {
            this.taskQueueMaxSize = taskQueueMaxSize;
        }

        public String getPoolNamPrefix() {
            return poolNamPrefix;
        }

        public void setPoolNamPrefix(String poolNamPrefix) {
            this.poolNamPrefix = poolNamPrefix;
        }

        public int getPoolCoreSize_default() {
            return poolCoreSize_default;
        }

        public void setPoolCoreSize_default(int poolCoreSize_default) {
            this.poolCoreSize_default = poolCoreSize_default;
        }

        public int getPoolMaxSize_default() {
            return poolMaxSize_default;
        }

        public void setPoolMaxSize_default(int poolMaxSize_default) {
            this.poolMaxSize_default = poolMaxSize_default;
        }

        public int getTaskQueueMaxSize_default() {
            return taskQueueMaxSize_default;
        }

        public void setTaskQueueMaxSize_default(int taskQueueMaxSize_default) {
            this.taskQueueMaxSize_default = taskQueueMaxSize_default;
        }

        private PoolConfig printInitInfoAndReturnUse(boolean isOnlyUseCore){
            PoolConfig us = new PoolConfig(this.poolNamPrefix);
            logger.info(String.format("****************************************%-5s初始化【%-25s】线程池配置项 开始%-5s****************************************","",us.getPoolNamPrefix(),""));
            if (isOnlyUseCore){
                //只有核心配置  那么max也使用核心配置
                us.setPoolCoreSize(this.poolCoreSize == -1?this.poolCoreSize_default:this.poolCoreSize);
                us.setPoolMaxSize(us.getPoolCoreSize());
                us.setTaskQueueMaxSize(Integer.MAX_VALUE);
                logger.info(String.format("**************%-4s 加载 %-25s - %-20s  默认值: %-8d yml配置: %-8d 启动使用配置: %-5d**************",
                        "",us.getPoolNamPrefix(),"poolCoreSize", us.getPoolCoreSize_default(),this.poolCoreSize,us.getPoolCoreSize()));
                logger.info(String.format("**************%-4s 加载 %-25s - %-20s  默认值: %-8d yml配置: %-8d 启动使用配置(使用core配置项): %-5d**************",
                        "",us.getPoolNamPrefix(),"poolMaxSize", us.getPoolMaxSize_default(), this.poolMaxSize,us.getPoolMaxSize()));
            }else {
                us.setPoolCoreSize(this.poolCoreSize == -1?this.poolCoreSize_default:this.poolCoreSize);
                us.setPoolMaxSize(this.poolMaxSize == -1?this.poolMaxSize_default:this.poolMaxSize);
                us.setTaskQueueMaxSize(this.taskQueueMaxSize == -1 ?this.taskQueueMaxSize_default : this.taskQueueMaxSize);
                logger.info(String.format("**************%-4s 加载 %-25s - %-20s  默认值: %-8d yml配置: %-8d 启动使用配置: %-5d**************",
                        "",us.getPoolNamPrefix(),"poolCoreSize", us.getPoolCoreSize_default(),this.poolCoreSize,us.getPoolCoreSize()));
                logger.info(String.format("**************%-4s 加载 %-25s - %-20s  默认值: %-8d yml配置: %-8d 启动使用配置: %-5d**************",
                        "",us.getPoolNamPrefix(),"poolMaxSize",us.getPoolMaxSize_default(), this.poolMaxSize,us.getPoolMaxSize()));
                logger.info(String.format("**************%-4s 加载 %-25s - %-20s  默认值: %-8d yml配置: %-8d 启动使用配置: %-5d**************",
                        "",us.getPoolNamPrefix(),"taskQueueMaxSize", us.getTaskQueueMaxSize_default(), this.taskQueueMaxSize,us.getTaskQueueMaxSize()));
            }
            logger.info(String.format("****************************************%-5s初始化【%-25s】线程池配置项 结束%-5s****************************************","",us.getPoolNamPrefix(),""));
            return us;
        }

    }

}
通过引入线程池提升QT程序的并发性能
yang1fei2的博客
04-19 1788
在程序开发过程中，开发者总是想尽可能的充分利用计算机的硬件性能来提升程序的执行效率。为了达到这个目标我们会尽可能多的引入多线程来提升程序的并发性能。在QT程序中我们也可以通过引入多线程来提升程序的执行效率，但是在引入多线程的时候，要对项目架构进行严格的设计，避免出现死锁、僵尸线程甚至卡死界面的情况。 包含线程池的QT项目的一般架构如下图所示: JobWidget对象存在于UI线程中，负责计算结果呈现和与用户的交互操作。 JobManager对象存在于JobManager线程中，该线程负责计算任务的
Java 线程池技术之一 自实现线程池
热门推荐
IterZebra
09-15 1万+
尽管自jdk1.5，Java已经自带了线程池实现，了解如何自己实现Java线程池有助于加深对操作系统和Java虚拟机的理解。 一，线程池的基本要素 线程池一般需要一个线程管理类： ThreadPoolManager，其作用有：   1）提供创建一定数量的线程
SpringBoot：自定义线程池配置类
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
03-29 1064
有时候我们在项目中做一些长链路的跑批任务时，基于Springboot项目的定时任务，我们可以指定一个自定义的线程配置类进行单独提供给具体跑批任务使用，而不占用整个系统资源。
十二、连接池线程池配置——HttpClient连接池
流楚丶格念的博客
08-27 1874
3.x、4.x 和 5.x API 是完全不兼容的，使用起来比较麻烦。在 HttpClient 的执行过程中，连接复用是一个关键的性能优化点。通过合理配置连接池参数、正确处理连接的使用和释放，以及关注连接池的生命周期和性能监控，可以有效提高。下面是对连接池源码的重要步骤分析，包括连接的复用和非复用情况的处理，以及连接池内部的数据结构。此异常通常表示连接池中的连接用尽，导致无法获取到可用连接。这种状态表示线程在等待连接池中的连接。时，到每个主机的并发最多只有 200，但总的并发连接数为 300。
线程池配置类
sdaujsj1的博客
12-04 526
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; import java.util.concurrent.ThreadPoolExecutor; @Configuration publ.
springboot单类集中定义线程池
weixin_36098377的博客
01-20 262
1、在启动类上加注解 @EnableAsync 2、定义线程池的类 package com.javabase.Thread; import com.google.common.util.concurrent.ThreadFactoryBuilder; import java.util.concurrent.*; public class EventThreadPool extends ThreadPoolExecutor { /** * 定义线程工厂名称 */ .
线程池概念 一、定义线程池类
11-01 369
public class ConcurrentTaskExecutor implements Executor {      private ThreadPoolExecutor executor = null;     private int corePoolSize = 5;     private int maxPoolSize = 10;     private int keep
线程池配置及应用
qq_20460289的博客
05-14 512
JAVA线程池配置详解 文章目录JAVA线程池配置详解线程池最优大小配置ThreadPoolExecutor管理排队任务饱和策略线程工厂在创建后定制ThreadPoolExecutor 网易面试时被面试官问到Java线程池的最优参数配置时没有答出来，面试官推荐了《Java并发编程实践》这本书。然而在阅读《Java并发编程实践》时，感觉这本书的翻译真的是一言难尽，因此决定翻译一下英文原版《Java Concurrency In Practic》书中的线程池配置章节。如翻译有错误或者不好的位置，欢迎指出，互相交
Spring Boot中配置定时任务、线程池与多线程池执行的方法
08-25
在Spring Boot应用中，我们可以利用其提供的功能来配置和管理定时任务、线程池以及多线程池执行。这些配置对于构建高效、可扩展的应用至关重要，尤其是在处理并发和定时任务调度时。 首先，我们来看看如何配置基础...
十二、连接池线程池配置——线程池
最新发布
流楚丶格念的博客
08-27 1108
如果需要在 Spring Boot 中创建自定义线程池（例如用于特定的任务或服务），可以使用。
spring boot使用自定义配置的线程池执行Async异步任务
08-28
在 Spring Boot 中使用自定义配置的线程池执行 Async 异步任务，可以通过定义自定义的配置类、创建线程池和开启配置支持来实现。在实际项目中，我们可以根据项目的需求来定制自己的线程池，以提高系统的性能和灵活性...
【SpringBoot】线程池自定义配置
人生苦短，我用python
07-05 1358
SpringBoot使用线程池
SpringBoot配置线程池
YIYIYI
12-16 3578
SpringBoot配置线程池
工具类-ThreadUtil线程池命名
没啥简介
01-11 740
工具类-ThreadUtil线程池命名先引入guava依赖定义工具类使用工具类命名各个线程 线程池命名可以方便以后排查问题，根据线程就知道哪个业务逻辑出了问题。 先引入guava依赖 <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>20.0</version> <
Java 线程池的创建及使用
BUG-制造机
09-07 201
Java 线程池的创建及使用
线程池
csdn_9527666的博客
03-31 182
线程池原理： 每一个 Thread 的类都有一个 start 方法。 当调用start启动线程时Java虚拟机会调用该类的 run 方法。 那么该类的 run() 方法中就是调用了 Runnable 对象的 run() 方法。 我们可以继承重写 Thread 类，在其 start 方法中添加不断循环调用传递过来的 Runnable 对象。 这就是线程池的实 现原理。循环方法中不断获取 Run...
JAVA线程池创建的几种方式，有案例很细！！！（持续更新中）
骑电动车小黄
09-03 4054
池（Pool），可以把它理解为一个容器，里面装着各种我们所需要的资源，我们需要资源的时候去这个容器里面拿，而不需要每次使用的时候去创建，从而达到一个复用的效果提高资源可利用率。
BCIT连接池单例实现与配置详解
这些配置信息存储在`Properties`对象中，通过`getResourceAsStream()`方法从类路径中获取配置文件流。 连接池的关键设置包括： 1. `setInitialSize(3)`：设置了初始化时的连接数量，即最少有多少个连接可供使用。 2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值