springboot 利用线程池实现多线程优化查询速度的一个小案例

最新推荐文章于 2024-04-29 15:47:35 发布
最新推荐文章于 2024-04-29 15:47:35 发布
阅读量1.7k 收藏 9
点赞数
分类专栏： java 文章标签： spring boot java 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cs95T6/article/details/128157694
版权

使用场景

最近开发中遇到一个问题，一个老系统的页面打开非常慢，因为一个接口中处理了各种逻辑的统计，给前端返回一个结果，会导致查询速度比较慢，在不考虑拆分接口（这样前端也需要调整）做速度的优化，多线程是一种比较好的选择
Controller 层

    @GetMapping("/listNumber")
    public AjaxResult listNumber(FollowUpVO fuVO) {
        SysUser user = SecurityUtils.getLoginUser().getUser();
        Set<String> permissions = permissionService.getMenuPermission(user);
        return AjaxResult.success(followUpService.listNumberNew(fuVO,permissions));
    }

ServiceImpl层

 @Override
    public FollowUpStatistics listNumberNew(FollowUpVO fuVO,Set<String> permissions) throws BusinessException {
        FollowUpStatistics fus = new FollowUpStatistics();
        String numberShow = sysConfigService.selectConfigByKey("doctor_number_show");
        if(StringUtils.isNotEmpty(numberShow)&&"2".equals(numberShow)){
            return fus;
        }
        if (fuVO.getDeptIds() == null || fuVO.getDeptIds().size() == 0) {
            List<Long> list = new ArrayList<>();
            list.add(SecurityUtils.getLoginUser().getUser().getDeptId());
            fuVO.setDeptIds(list);
        }

        //由于登录人可以右上角切换人员角色，因此这里需要重新查询一下
        SysUser LoginUser = SecurityUtils.getLoginUser().getUser();
        SysUser userInfo = sysUserMapper.selectUserById(LoginUser.getUserId());
        String userType = userInfo.getUserType();
        fuVO.setUserType(userType);
        String userId ="";
        String deptId ="";
        if(userInfo.getUserId()!=null){
            userId = userInfo.getUserId().toString();
        }
        if(userInfo.getDeptId()!=null){
            deptId = userInfo.getDeptId().toString();
        }
        fuVO.setDeptId(Long.valueOf(deptId));
        fuVO.getDeptIds().add(Long.valueOf(deptId));
        fuVO.setCreateBy(SecurityUtils.getLoginUser().getUser().getUserId().toString());

        followUpMapper.listWaitAssessNum(fuVO);
        //使用多线程来查询组装数据
        Future<Integer> waidtFollowUpNum = doctorWorkNumberService.listWaitFollowUpNum(fuVO,permissions);
        Future<Integer> evaluationResult = doctorWorkNumberService.queryEvaluationResultCount(fuVO,userId,userType,deptId,permissions);
        Future<Integer> listWaitGradedNum = doctorWorkNumberService.listWaitGradedNum(fuVO,permissions);
        Future<Integer> waitGuideBaseNum = doctorWorkNumberService.listWaitGuideBaseNum(fuVO,permissions);

        Future<Integer> waitAssessNum = doctorWorkNumberService.listWaitAssessNum(fuVO,permissions);
        Future<Integer> notManageNum = doctorWorkNumberService.listNotManageNum(fuVO,permissions);
        Future<Integer> healthNotManageNum = doctorWorkNumberService.listHealthNotManageNum(fuVO,permissions);
        Future<Integer> reManageNum = doctorWorkNumberService.listReManageNum(fuVO,permissions);

        Future<Integer> attentionNum = doctorWorkNumberService.listAttentionNum(fuVO,permissions);
        Future<Integer> workDoneNum = doctorWorkNumberService.listWorkDoneNum(fuVO,permissions);
        Future<Integer> waitSubsequentVisitNum = doctorWorkNumberService.listWaitSubsequentVisitNum(fuVO,permissions);

        while ( !waidtFollowUpNum.isDone()
                ||!evaluationResult.isDone()
                ||!listWaitGradedNum.isDone()
                ||!waitGuideBaseNum.isDone()

                ||!waitAssessNum.isDone()
                ||!notManageNum.isDone()
                ||!healthNotManageNum.isDone()
                ||!reManageNum.isDone()
                ||!workDoneNum.isDone()
                ||!attentionNum.isDone()
                ||!waitSubsequentVisitNum.isDone()
                ){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        try {
            fus.setWaitFollowUpNum(waidtFollowUpNum.get());
            fus.setFollowUpResultNum(evaluationResult.get());
            fus.setWaitGradedNum(listWaitGradedNum.get());
            fus.setWaitGuideBaseNum(waitGuideBaseNum.get());
            fus.setWaitAssessNum(waitAssessNum.get());
            fus.setNotManageNum(notManageNum.get());
            fus.setHealthNotManageNum(healthNotManageNum.get());
            fus.setReManageNum(reManageNum.get());
            fus.setAttentionNum(attentionNum.get());
            fus.setWaitSubsequentVisitNum(waitSubsequentVisitNum.get());
            fus.setWorkDoneNum(workDoneNum.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        return fus;
    }

单独为里面每个小任务单独定义一个DoctorWorkNumberService 其中 @Async(“threadPoolTaskExecutor”)等注解 标明用哪个线程池配置

package com.xikang.doctorWorkstation.service.impl;

import com.xikang.common.enums.Permissions;
import com.xikang.common.utils.DateUtils;
import com.xikang.doctorWorkstation.domain.vo.FollowUpVO;
import com.xikang.doctorWorkstation.mapper.FollowUpMapper;
import com.xikang.doctorWorkstation.mapper.WorkDoneMapper;
import com.xikang.doctorWorkstation.mapper.WorkstationAttentionMapper;
import com.xikang.hypertension.domain.vo.AutoEvaluationPo;
import com.xikang.hypertension.mapper.GxyEvaluationBaseMapper;
import com.xikang.hypertension.mapper.SubsequentVisitMapper;
import com.xikang.system.mapper.DiseaseDepartmentRelationMapper;
import com.xikang.system.mapper.SysDeptMapper;
import com.xikang.system.mapper.SysUserMapper;
import com.xikang.system.service.ISysConfigService;
import com.xikang.visitInformation.mapper.VisitInformationMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Set;
import java.util.concurrent.Future;

import static com.xikang.common.utils.DateUtils.getDateAgoOrAfterDays;

@Service
public class DoctorWorkNumberService {
    @Autowired
    private FollowUpMapper followUpMapper;
    @Autowired
    private SysUserMapper sysUserMapper;
    @Autowired
    private SysDeptMapper deptMapper;
    @Autowired
    private WorkstationAttentionMapper workstationAttentionMapper;
    @Autowired
    private WorkDoneMapper workDoneMapper;
    @Resource
    private SubsequentVisitMapper subsequentVisitMapper;
    @Resource
    private ISysConfigService sysConfigService;
    @Resource
    private VisitInformationMapper visitInformationMapper;
    @Resource
    private DiseaseDepartmentRelationMapper relationMapper;
    @Resource
    private GxyEvaluationBaseMapper gxyEvaluationBaseMapper;

    public String PrintDate(Long startTime, Long endTime, String note){
        Long tempTime = (endTime - startTime);
        String result = note + (((tempTime/86400000)>0)?((tempTime/86400000)+"d"):"")+
                ((((tempTime/86400000)>0)||((tempTime%86400000/3600000)>0))?((tempTime%86400000/3600000)+"h"):(""))+
                ((((tempTime/3600000)>0)||((tempTime%3600000/60000)>0))?((tempTime%3600000/60000)+"m"):(""))+
                ((((tempTime/60000)>0)||((tempTime%60000/1000)>0))?((tempTime%60000/1000)+"s"):(""))+
                ((tempTime%1000)+"ms");
        System.out.println(result);
        return result;
    }


    /**
     * @Description:待随访数量
     *
     * @author zhangzhiqing
     * @date  2022/11/4 15:34
     */
    @Async("threadPoolTaskExecutor")
    public Future<Integer> listWaitFollowUpNum(FollowUpVO fuVO,Set<String> permissions){
        Long startTime = System.currentTimeMillis();
        Integer result = null;
        if(permissions.contains("*:*:*")||permissions.contains(Permissions.TOFOLLOWUP.getCode())){
            result = followUpMapper.listWaitFollowUpNum(fuVO);
        }

        PrintDate(startTime, System.currentTimeMillis(), "待随访数量");
        return new AsyncResult<>(result);
    }

    /**
     * @Description:自动随访结果数量
     *
     * @author zhangzhiqing
     * @date  2022/11/4 15:34
     */
    @Async("threadPoolTaskExecutor")
    public Future<Integer> queryEvaluationResultCount(FollowUpVO fuVO,String userId,String userType,String deptId,Set<String> permissions){
        Long startTime = System.currentTimeMillis();
        Integer result = null;
        if(permissions.contains("*:*:*")||permissions.contains(Permissions.AUTOEVALUATIONRESULT.getCode())) {
            AutoEvaluationPo autoEvaluationPo = new AutoEvaluationPo();
            autoEvaluationPo.setEvaluationType("不良反应,控制不满意");
            autoEvaluationPo.setEndEvaluationDate(DateUtils.getDate());
            autoEvaluationPo.setStartEvaluationDate(DateUtils.parseDateToStr("yyyy-MM-dd",getDateAgoOrAfterDays(DateUtils.getNowDate(),-7)));
            //健康管理师
            if("1".equals(userType)){
                autoEvaluationPo.setManageHealthId(userId);
                //管理医生
            }else if("2".equals(userType)){
                autoEvaluationPo.setManageDoctorId(userId);
            }
            autoEvaluationPo.setManageDeptId(deptId);
            result = gxyEvaluationBaseMapper.queryEvaluationResultCount(autoEvaluationPo);
        }
        PrintDate(startTime, System.currentTimeMillis(), "自动随访结果数量");
        return new AsyncResult<>(result);
    }

    /**
     * @Description:待分级数量
     *
     * @author zhangzhiqing
     * @date  2022/11/4 15:34
     */
    @Async("threadPoolTaskExecutor")
    public Future<Integer> listWaitGradedNum(FollowUpVO fuVO,Set<String> permissions){
        Integer result = null;
        Long startTime = System.currentTimeMillis();
        if(permissions.contains("*:*:*")||permissions.contains(Permissions.TOGRADED.getCode())) {
            String mustGradeFlag = "是";
            //随访之后必须分级参数
            String mustGrade = sysConfigService.selectConfigByKey("must_grade");
            if (mustGrade.equals(mustGradeFlag)) {
                //待分级数量
                result = followUpMapper.listWaitGradedNumAndEvaluation(fuVO);
            } else {
                //待分级数量
                result = followUpMapper.listWaitGradedNum(fuVO);
            }
        }
        PrintDate(startTime, System.currentTimeMillis(), "待分级数量");
        return new AsyncResult<>(result);
    }

    /**
     * @Description:待制定管理方案数量
     *
     * @author zhangzhiqing
     * @date  2022/11/4 15:34
     */
    @Async("threadPoolTaskExecutor")
    public Future<Integer> listWaitGuideBaseNum(FollowUpVO fuVO,Set<String> permissions){
        Long startTime = System.currentTimeMillis();
        String mustGuideFlag = "是";
        Integer result = null;
        if(permissions.contains("*:*:*")||permissions.contains(Permissions.TOMANAGEMENTPLAN.getCode())) {
            //随访之后必须指定管理方案
            String mustGuide = sysConfigService.selectConfigByKey("must_guide");
            if (mustGuide.equals(mustGuideFlag)) {
                //待制定管理方案数量
                result = followUpMapper.listWaitGuideBaseNumAndEvaluation(fuVO);
            } else {
                //待制定管理方案数量
                result = followUpMapper.listWaitGuideBaseNum(fuVO);
            }
        }
        PrintDate(startTime, System.currentTimeMillis(), "待制定管理方案数量");
        return new AsyncResult<>(result);
    }

    /**
     * @Description:待管理评估数量
     *
     * @author zhangzhiqing
     * @date  2022/11/4 15:34
     */
    @Async("threadPoolTaskExecutor")
    public Future<Integer> listWaitAssessNum(FollowUpVO fuVO,Set<String> permissions){
        Long startTime = System.currentTimeMillis();

        Integer result = null;
        if(permissions.contains("*:*:*")||permissions.contains(Permissions.TOMANAGEDASSESSMENT.getCode())) {
            result = followUpMapper.listWaitAssessNum(fuVO);
        }

        PrintDate(startTime, System.currentTimeMillis(), "待管理评估数量");
        return new AsyncResult<>(result);
    }

    /**
     * @Description:未管理数量
     *
     * @author zhangzhiqing
     * @date  2022/11/4 15:34
     */
    @Async("threadPoolTaskExecutor")
    public Future<Integer> listNotManageNum(FollowUpVO fuVO,Set<String> permissions){
        Long startTime = System.currentTimeMillis();
        Integer result = null;
        if(permissions.contains("*:*:*")||permissions.contains(Permissions.UNMANAGED.getCode())) {
            result = followUpMapper.listNotManageNum(fuVO);
        }
        PrintDate(startTime, System.currentTimeMillis(), "未管理数量");

        return new AsyncResult<>(result);
    }

    /**
     * @Description:未管理数量-健康管理师
     *
     * @author zhangzhiqing
     * @date  2022/11/4 15:34
     */
    @Async("threadPoolTaskExecutor")
    public Future<Integer> listHealthNotManageNum(FollowUpVO fuVO,Set<String> permissions){
        Long startTime = System.currentTimeMillis();
        Integer result = null;

        if(permissions.contains("*:*:*")||permissions.contains(Permissions.HEALTHUNMANAGED.getCode())){
            result = followUpMapper.listHealthNotManageNum(fuVO);
        }
        PrintDate(startTime, System.currentTimeMillis(), "未管理数量-健康管理师");

        return new AsyncResult<>(result);
    }


    /**
     * @Description:失管复诊数量
     *
     * @author zhangzhiqing
     * @date  2022/11/4 15:34
     */
    @Async("threadPoolTaskExecutor")
    public Future<Integer> listReManageNum(FollowUpVO fuVO,Set<String> permissions){
        Long startTime = System.currentTimeMillis();
        Integer result = null;

        if(permissions.contains("*:*:*")||permissions.contains(Permissions.REMANAGE.getCode())){
            result = followUpMapper.listReManageNum(fuVO);
        }

        PrintDate(startTime, System.currentTimeMillis(), "失管复诊数量");
        return new AsyncResult<>(result);
    }
    /**
     * @Description:收藏数量
     *
     * @author zhangzhiqing
     * @date  2022/11/4 15:34
     */
    @Async("threadPoolTaskExecutor")
    public Future<Integer> listAttentionNum(FollowUpVO fuVO,Set<String> permissions){
        Long startTime = System.currentTimeMillis();

        Integer result = workstationAttentionMapper.listNumber(fuVO);
        PrintDate(startTime, System.currentTimeMillis(), "收藏数量");

        return new AsyncResult<>(result);
    }


    /**
     * @Description:已办数量
     *
     * @author zhangzhiqing
     * @date  2022/11/4 15:34
     */
    @Async("threadPoolTaskExecutor")
    public Future<Integer> listWorkDoneNum(FollowUpVO fuVO,Set<String> permissions){
        Long startTime = System.currentTimeMillis();

        Integer result = workDoneMapper.listNumber(fuVO);
        PrintDate(startTime, System.currentTimeMillis(), "已办数量");

        return new AsyncResult<>(result);
    }


    /**
     * @Description:待复诊数量  无健康管理师
     *
     * @author zhangzhiqing
     * @date  2022/11/4 15:34
     */
    @Async("threadPoolTaskExecutor")
    public Future<Integer> listWaitSubsequentVisitNum(FollowUpVO fuVO,Set<String> permissions){
        Long startTime = System.currentTimeMillis();
        Integer result = null;
        if(permissions.contains("*:*:*")||permissions.contains(Permissions.TOFOLLOWUPVISIT.getCode())){
            //待复诊数量  无健康管理师
            fuVO.setManageHealth(null);
            result = followUpMapper.listWaitSubsequentVisitNum(fuVO);
        }
        PrintDate(startTime, System.currentTimeMillis(), "待复诊数量");
        return new AsyncResult<>(result);
    }
}

线程池配置 ThreadPoolConfig

package com.xikang.framework.config;

import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor;
import org.apache.commons.lang3.concurrent.BasicThreadFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import com.xikang.common.utils.Threads;

/**
 * 线程池配置
 *
 * @author xikang
 **/
@Configuration
public class ThreadPoolConfig
{
    // 核心线程池大小
    private int corePoolSize = 50;

    // 最大可创建的线程数
    private int maxPoolSize = 200;

    // 队列最大长度
    private int queueCapacity = 1000;

    // 线程池维护线程所允许的空闲时间
    private int keepAliveSeconds = 300;

    @Bean(name = "threadPoolTaskExecutor")
    public ThreadPoolTaskExecutor threadPoolTaskExecutor()
    {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setMaxPoolSize(maxPoolSize);
        executor.setCorePoolSize(corePoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(keepAliveSeconds);
        // 线程池对拒绝任务(无线程可用)的处理策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }

    /**
     * 执行周期性或定时任务
     */
    @Bean(name = "scheduledExecutorService")
    protected ScheduledExecutorService scheduledExecutorService()
    {
        return new ScheduledThreadPoolExecutor(corePoolSize,
                new BasicThreadFactory.Builder().namingPattern("schedule-pool-%d").daemon(true).build())
        {
            @Override
            protected void afterExecute(Runnable r, Throwable t)
            {
                super.afterExecute(r, t);
                Threads.printException(r, t);
            }
        };
    }

    @Bean
    public TaskExecutor customTaskExecutor() {
        return buildSequentialExecutor("customTaskExecutor", 50000);
    }

    /**
     * 创建一个可以顺序执行的执行器，通过设置线程池只有一个线程和队列的方式来保证顺序执行
     * @param executorName
     * @param queueSize
     * @return
     */
    private ThreadPoolTaskExecutor buildSequentialExecutor(String executorName, int queueSize) {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(1);
        executor.setMaxPoolSize(1);
        executor.setQueueCapacity(queueSize);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("spring-async-".concat(executorName));
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        return executor;
    }
}

总结

经过优化以后，接口从超时变成 8s 也不快总之不报错了。也不用前端配合拆接口，很nice

cs95T6
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
springboot 多线程实现
m0_67393295的博客
07-28 2300
有时候，，如果，系统就要，有时会。而且当线程数量太多时，
Java多线程之定时任务 以及 SpringBoot多线程实现定时任务——异步任务
03-12
1. SpringBoot 自定义线程池以及多线程间的异步调用（@Async、@EnableAsync） 2.Java多线程之定时任务 以及 SpringBoot多线程实现定时任务 3.@EnableScheduling 与 @Scheduled
Springboot线程池并发处理数据优化
S&Y_shhy_QQ_1127833416
08-21 2429
第一步：首先配置线程基本参数，可以放在application.propertes文件种也可以放在自己新建的config/文件目录下，注意：但是需要使用@PropertySource把配置文件进行加载。 # 异步线程配置 # 配置核心线程数 async.executor.thread.core_pool_size = 8 # 配置最大线程数 async.executor.thread.max_p...
使用线程池+分页查询大数据用来导出
JAVA_ZHZ的博客
12-28 1706
需求：最近需要做一个大数据的导入导出，数据量21w条30个字段。下面主要记录一次做导出时大数据的查询。思路：如果一次数据库查询太多数据，jvm就会内存溢出，所以我使用分页每次查询1万条数据，使用for循环，再把结果合并到一起。但是这种串行方式是阻塞的，查询21w数据大约需要15秒，然后就通过线程池用多线程查询，21w条数据用时2秒多。提示：以下是本篇文章正文内容，下面案例可供参考。
springboot 多线程查询
最新发布
weixin_46592850的博客
04-29 193
【代码】springboot 多线程查询。
详解Spring-Boot中如何使用多线程处理任务
08-31
本篇文章主要介绍了详解Spring-Boot中如何使用多线程处理任务，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。
SpringBoot--多线程处理
热门推荐
IT利刃出鞘的博客
07-31 1万+
本文介绍SpringBoot多线程处理的方案。
SpringBoot中多线程批处理并获取处理结果的实现
weixin_44794056的博客
03-24 2287
在SpringBoot框架中使用多线程，对大量相同进行批处理的一种实现方式。
springboot使用多线程进行扫描文件以及读取数据库
weixin_42759398的博客
05-24 1481
在这个方法中，我们使用BufferedReader从文件中读取每一行数据，然后对数据的每一个字段进行处理，处理后将数据保存到数据库。在上面的代码中，我们将添加文章的方法addArticle中的任务filterSensitiveWords使用@Async注解进行了异步处理，这样当用户调用addArticle方法时，敏感词过滤任务会异步执行，用户不必等待它的完成。假设我们有一个需求，需要从一个非常大的csv文件中读取数据，然后将其中某些字段的值进行处理，最后将处理后的数据保存到数据库中。
基于SpringBoot和POI实现单线程和多线程导出Excel.zip
12-17
基于SpringBoot和POI实现单线程和多线程导出Excel.zip基于SpringBoot和POI实现单线程和多线程导出Excel.zip基于SpringBoot和POI实现单线程和多线程导出Excel.zip基于SpringBoot和POI实现单线程和多线程导出Excel.zip...
SpringBoot 多任务并行+线程池处理的实现
08-27
SpringBoot 多任务并行+线程池处理的实现 SpringBoot 多任务并行+线程池处理是 SpringBoot 框架中的一种高效的并发处理机制。它通过使用线程池来管理多个任务的并行执行，从而提高系统的性能和可扩展性。在本文中，...
SpringBoot版本的多线程下载文件，分段下载文件
11-24
新鲜出炉的SpringBoot版本的多线程下载文件，可以拿来整合SpringBoot项目或者SSM项目，可直接运行测试！！！
SpringBoot2线程池定义使用方法解析
08-19
线程池是Java中的一种多线程编程模式，用于提高程序的执行效率和响应速度。 SpringBoot2框架提供了ThreadPoolTaskExecutor来实现线程池的定义和使用。 线程池的定义 在SpringBoot2中，我们可以通过定义...
【SpringBoot】springboot数据使用多线程批量入数据库
superKusch的博客
02-02 5467
Spring实现事务的原理是通过ThreadLocal把数据库连接绑定到当前线程中，同一个事务中数据库操作使用同一个jdbc connection，新开启的线程获取不到当前jdbc connection。可见时间从180秒，缩短到了28秒，但是@Transactional对于多线程是控制不了所有的事务的。可见5个线程都报错了，但是去查询数据库，却可以查询到5000条数据，这是不应该出现的情况。分别放开子线程报错和主线程报错，会发现事务都可以正常回滚，达到了预期的效果。耗时时间：87217ms。
【SpirngBoot】EasyExcel 多线程 + 分批次查询数据，逐步导出，降低内存占用，通用模板适用于所有的导出
hs598375774的博客
05-25 4723
以上思路即是针对数据量较大情况下处理方式，如有文件服务器可采用异步+多线程方式生成文件上传到文件服务器，用户点击下载弹出下载页面，用户下载文件服务中附件，此文件可重复下载，减轻相同的再次生成文件执行业务代码等流程。将查询到的数据使用 EasyExcel 进行导出，导出时可以采用异步导出的方式，这样可以避免导出数据量过大导致的内存溢出问题。需要注意的是，在使用 inMemory 方式导出数据时，需要注意内存溢出的问题。在 Controller 层中，定义一个导出接口，接口中传入需要导出的数据的查询条件。
JAVA SpringBoot 项目 多线程、线程池的使用。
qq_33286757的博客
08-08 841
它的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后 启动这些任务，如果线程数量超过了最大数量超出数量的线程排队等候，等其它线程执行完毕， 再从队列中取出任务来执行。总之，只要是有并发的地方、任务量大或者小、每个任务执行时间长或短的都可以使用线程池，只不过在使用线程池的时候，注意下设置合理的线程池大小即可；（3）提升系统的响应速度，假如创建线程用的时间为T1，执行任务用的时间为T2，销毁线程用的时间为T3，那么使用线程就免去了T1和T3的时间。，且可以对所有的线程。
springBoot中service层查询使用多线程CompletableFuture（有返回值）
weixin_47615289的博客
08-15 1512
【代码】springBoot中service层查询使用多线程CompletableFuture（有返回值）
Springboot下整合多线程 异步操作 查询数据库
weixin_41466150的博客
03-27 7095
pom.xml配置导入如下： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configuration-processor</artifactId> ...
SpringBoot多线程查询实战-查询库中所有数据多线程实现
勇敢牛牛，不怕困难！
03-27 2252
但是，在数据量较大且服务器资源足够的情况下，多线程方法通常能够显著提高查询效率。此外，由于它是同步执行的，没有利用并行处理的能力，所以在处理大量数据时可能会比较慢。这个方法采用了分页查询的方式，每次只获取一部分数据，从而避免了内存溢出的问题。然而，它也是同步执行的，没有利用多线程或并行处理的能力。如果每次分页查询的数据量仍然很大，或者需要查询的轮数很多，那么这种方法的效率可能仍然会受到限制。​ ​ ​在比较这三种方式的效率时，我们需要考虑几个关键因素：数据量的大小、查询操作的复杂性、以及并行处理的能力。
springboot 自定义线程池实现多线程
05-27
在 Spring Boot 中，我们可以使用 Java 提供的 Executor 框架来创建自定义的线程池，从而实现多线程。 以下是一个简单的自定义线程池示例： 首先，我们需要在 Spring Boot 的配置文件中配置线程池的参数： ```properties # 线程池配置 spring.task.execution.pool.core-size=10 spring.task.execution.pool.max-size=20 spring.task.execution.pool.queue-capacity=200 ``` 然后，在代码中我们可以通过注入 TaskExecutor 类型的 bean 来使用线程池： ```java @Service public class MyService { @Autowired private TaskExecutor taskExecutor; public void doSomething() { taskExecutor.execute(() -> { // 在这里编写需要使用线程池执行的任务 }); } } ``` 在上面的示例中，我们通过注入 TaskExecutor 类型的 bean 来获取线程池实例。然后，我们可以使用 execute() 方法来提交需要执行的任务。注意，execute() 方法接受的参数是一个 Runnable 对象，因此我们需要在其中编写需要使用线程池执行的任务。 在执行任务时，线程池会自动根据配置的参数来创建、管理和调度线程，从而实现多线程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值