SpringBoot使用异步线程处理热点接口提高接口并发

最新推荐文章于 2024-04-17 07:55:34 发布
最新推荐文章于 2024-04-17 07:55:34 发布
阅读量2.1k 收藏 27
点赞数 6
分类专栏： SpringBoot
本文链接：https://blog.csdn.net/weixin_42921178/article/details/106513999
版权

SpringBoot使用异步线程处理热点接口提高接口并发

环境参数

SpringBoot版本 ：2.1.0.RELEASE

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.0.RELEASE</version>
		<relativePath />
</parent>

配置步骤

1.配置项 @Configuration SysConfigure

自定义一个@Configuration 配置项
配置异步线程池
例如
/配置核心线程数/
/配置最大线程数/
/配置队列大小/
/活跃时间/
/配置线程池中的线程的名称前缀/
/设置拒绝策略：当pool已经达到max size的时候，如何处理新任务/

package com.xzk6.config;

import com.github.pagehelper.PageHelper;
import com.xzk6.config.async.AsyncTaskProperties;
import com.xzk6.constant.IConstants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.web.servlet.MultipartConfigFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import javax.servlet.MultipartConfigElement;
import java.util.Properties;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @author xzk
 */
@Configuration
@Slf4j
public class SysConfigure {
	/** 注入配置类 */
    private final AsyncTaskProperties config;

    public SysConfigure(AsyncTaskProperties config) {
        this.config = config;
    }

	/** 可定义注入Bean名称  和后续需要sync的方法使用 */
	@Bean(IConstants.ASYNC_POOL)
	public Executor asyncServiceExecutor() {
		log.info("start asyncServiceExecutor(狗头保命)");
		ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
		/**配置核心线程数**/
		executor.setCorePoolSize(config.getCorePoolSize());
		/**配置最大线程数**/
		executor.setMaxPoolSize(config.getMaxPoolSize());
		/**配置队列大小**/
		executor.setQueueCapacity(config.getQueueCapacity());
		/**活跃时间**/
        executor.setKeepAliveSeconds(config.getKeepAliveSeconds());
		/**配置线程池中的线程的名称前缀**/
		executor.setThreadNamePrefix("xzk6-syncThread-");
		/** 设置拒绝策略：当pool已经达到max size的时候，如何处理新任务**/
		/** CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行**/
		executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
		/**执行初始化**/
		executor.initialize();
		return executor;
	}

}

异步线程池Bean
在这里插入图片描述

线程池参数 AsyncTaskProperties

package com.xzk6.config.async;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * 线程池配置属性类
 * @author xzk
 * @date 2020年6月2日23:36:20
 */
@Data
@Component
@ConfigurationProperties(prefix = "task.pool")
public class AsyncTaskProperties {

    private int corePoolSize;

    private int maxPoolSize;

    private int keepAliveSeconds;

    private int queueCapacity;
}

2.配置文件 application.yml

task:
  pool:
    # 核心线程池大小
    core-pool-size: 10
    # 最大线程数
    max-pool-size: 30
    # 活跃时间
    keep-alive-seconds: 60
    # 队列容量
    queue-capacity: 3000

3.控制器 Controller

package com.xzk6.test.controller;


import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.xzk6.config.redis.RedisUtil;
import com.xzk6.controller.BaseController;
import com.xzk6.test.entity.Test5;
import com.xzk6.test.service.ITest5Service;
import com.xzk6.utils.PageUtil;
import com.xzk6.utils.ResultUtil;
import com.xzk6.utils.Util;
import com.xzk6.utils.UuidUtil;
import com.xzk6.utils.common.CommonUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.util.List;
import java.util.Map;

/**
 * <p>
 * 前端控制器
 * </p>
 *
 * @author xzk
 * @date 2020年6月2日23:47:46
 */

@Api(description = "测试")
@RestController
@RequestMapping("api/pub/test5")
@Slf4j
public class Test5Controller extends BaseController {

    @Autowired
    private ITest5Service iTest5Service;
    @Autowired
    private RedisUtil redisUtil;

    /**
     * 热点接口测试
     *
     * @param request
     * @param bean
     * @return JSONObject
     */
    @ApiOperation(value = "查看测试列表(分页)", notes = "查看测试列表(分页)", httpMethod = "POST")
    @ApiImplicitParams({})
    @ResponseBody
    @RequestMapping(value = "/testList", produces = "application/json;charset=utf-8")
    public Object findPageList(HttpServletRequest request,  Test5 bean) throws Exception {
        long timer1 = System.currentTimeMillis();
        String uuid = UuidUtil.get32UUID();
        Map<String, Object> param = Util.getRequestParams( request );
        log.info( "执行流水:开始[" + uuid + "]" + in_pageList + bean );
        Integer page = PageUtil.getPage( param );// 获取页码
        Integer size = PageUtil.getSize( param );// 获取条数
        PageHelper.startPage( page, size );
        List<Map<String, Object>> List = iTest5Service.findList( param );
        /** 假如我们这个 iTest5Service.test  操作是非同步实时处理。
        	我们可以异步处理来提高接口响应速度提高性能，
		        if(牛逼接口){
		       		 牛逼的技术驱动业务，
		        	 吊炸天的业务给公司带来利益，
		        	 然后我们升职加薪，隐去白富美，走上人生巅峰。
		        }else{
					菜鸡单体应用思维驱动不了互联网业务
					业务凉凉，项目不验收。
					老板开除你，
					你露宿接头，饥肠辘辘
					然后不小心吃了野味
					然后。。。
				}
				哈哈哈，
				我这只是一个小小的逻辑方式。提升性能方式、方法还很多。
				大家一起学习。然后一起发财
         **/
        iTest5Service.test(bean);
        PageInfo<Map<String, Object>> pageInfo = new PageInfo<Map<String, Object>>( List );
        int count = (int) pageInfo.getTotal();
        pageInfo = new PageInfo<Map<String, Object>>( ResultUtil.Listvaluechangenull( List ) );
        log.info( "执行流水:结束[" + uuid + "] 总耗时 " + (System.currentTimeMillis() -timer1) );
        return  CommonUtil.successJson( count,pageInfo.getList() );
    }

}

4.业务接口 Service

package com.xzk6.test.service;

import com.xzk6.test.entity.Test5;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
import java.util.Map;

/**
 * <p>
 *  服务类接口
 * </p>
 *
 * @author xzk
 * @since 2020年6月2日23:47:46
 */
public interface ITest5Service extends IService<Test5> {

    /**
     * <p>
     * 列表
     * </p>
     *
     * @param map
     * @return List<Map < String, Object>>
     * @author xzk
     * @date 2020-05-20
     */
    List<Map<String, Object>> findList(Map<String, Object> map) throws Exception;


    /**
     * <p>
     * 异步测试接口
     * </p>
     *
     * @param bean
     * @return void
     * @author xzk
     * @date 2020年6月2日23:47:46
     */
    void test(Test5 bean) throws Exception;

  

}



package com.xzk6.test.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xzk6.constant.IConstants;
import com.xzk6.mapper.test.Test5Mapper;
import com.xzk6.test.entity.Test5;
import com.xzk6.test.service.ITest5Service;
import com.xzk6.utils.UuidUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Map;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author xzk
 * @since 2020年6月2日23:47:46
 */
@Service
@Slf4j
public class Test5ServiceImpl extends ServiceImpl<Test5Mapper, Test5> implements ITest5Service {

    /**
     * <p>
     * 列表
     * </p>
     *
     * @param map
     * @return List<Map < String, Object>>
     * @author xzk
     * @date 2020年6月2日23:47:46
     */
    @Override
    public List<Map<String, Object>> findList(Map<String, Object> map) throws Exception {
        return baseMapper.findList( map );
    }

   
    /**
     * <p>
     * 异步测试接口
     * </p>
     *
     * @param bean
     * @return void
     * @author xzk
     * @date 2020年6月2日23:47:46
     */
    @Async(IConstants.ASYNC_POOL)
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public void test(Test5 bean) throws Exception {
       log.info("进入----异步 "+ bean);
       Thread.sleep(3000);
       log.info("结束----异步");
    }

    

}

核心是 在调用方法加上 @Async
核心是 在启动主类加上 @EnableAsync

package com.xzk6;

import com.github.xiaoymin.swaggerbootstrapui.annotations.EnableSwaggerBootstrapUI;
import com.xzk6.config.Init;
import lombok.extern.slf4j.Slf4j;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.transaction.annotation.EnableTransactionManagement;


/**
 * @author xzk
 */
@EnableAsync
@SpringBootApplication // boot
@EnableTransactionManagement// 事务
@EnableScheduling // 启用定时器
@EnableSwaggerBootstrapUI // swagger
//@ComponentScan("com.xzk6")
@MapperScan(basePackages = {"com.xzk6.mapper"})
@Slf4j
public class ApiApplication {

    /**
     * Start
     */
    public static void main(String[] args) {
        long timer = System.currentTimeMillis();
        SpringApplication springapplication = new SpringApplication( ApiApplication .class );
        ApplicationContext applicationContext = springapplication.run( args );
        log.info( "------------------Bean Nums" + applicationContext.getBeanDefinitionCount() );
        Init.init();// 启动私有服务
        log.info( "服务启动[成功] 耗时:[" + ((System.currentTimeMillis() - timer) / 1000) + " 秒]" );
    }
}

完成！ 是不是很简单 来验证结果

5.结果

在这里插入图片描述
瞌睡。睡觉。大家晚安。
我是一个莫得感情努力赚钱的工具人
在这里插入图片描述

在这里插入图片描述

晗晗最美
关注
  • 6
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot实现高吞吐量异步处理详解(适用于高并发场景)
08-25
主要介绍了Springboot实现高吞吐量异步处理详解(适用于高并发场景)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
线程异步、接口回调
weixin_30596165的博客
07-06 160
一、线程的实现（异步机制、耗时操作） Thread： Runnable： Handler： 在Handler 异步实现时,涉及到 Handler, Looper, Message,Thread四个对象， 实现异步的流程是主线程启动Thread（子线程）àthread(子线程)运行并生成 Message-àLooper获取Message并传递给HandleràHandler逐...
SpringBoot中使用异步方法优化Service逻辑，提高接口响应速度
最新发布
2401_83916204的博客
04-17 692
2. SpringBoot中的异步方法支持其实, 在SpringBoot中并不需要我们自己去创建维护线程或者线程池来异步的执行方法, SpringBoot已经提供了异步方法支持注解.@EnableAsync // 使用异步方法时需要提前开启(在启动类上或配置类上)@Async // 被async注解修饰的方法由SpringBoot默认线程池(SimpleAsyncTaskExecutor)执行比如使用Spring的异步支持实现文章查询并增加阅读量Service层:@Service。
SpringBoot异步接口调用与多线程线程池使用注意事项说明
纸上得来终觉浅，绝知此事要躬行
04-27 8212
Java多线程相关说明 异步调用分为两类 有返回值：用户需要Callable、Futrue等来接收最终的处理结果，但这个过程是异步非阻塞的。 无返回值：用户提交请求到接口之后不需要任何返回值，请求到达服务端之后就没有任何关系了，用户可以不等待而去做其他的业务操作。 多线程调用方法 Callable:有返回值的线程方法，call 将会对用户请求做出结果反馈。 Runnable:线程的接口，...
SpringBoot项目@Async默认线程池导致OOM问题?
赵侠客
07-28 2657
最近看到一篇文章说SpringBoot项目中@Async默认线程池会导致OOM,因为我的项目中也用到@Async注解，所以赶紧看了一下，在网上搜索@Async导致OOM案例还是很多的，于是我就研究了一下。
springboot使用多线程处理高并发接口
wppwpp1的专栏
11-08 5879
当线程增加到cpu的个数的时候，吞吐率会达到顶峰，
springboot高并发下提高吞吐量的实现
08-25
本文将详细介绍如何使用多线程技术来提高 SpringBoot 应用程序的吞吐量，从而解决高并发场景下的性能问题。 知识点 1: 高并发下的性能问题 在高并发场景下，SpringBoot 应用程序的性能问题变得非常突出。如果不...
spring boot中多线程开发的注意事项总结
08-26
首先，为了启用异步任务处理，我们需要在配置类上使用`@EnableAsync`注解，这使得Spring Boot能够识别并处理带有`@Async`注解的方法。例如： ```java @Configuration @EnableAsync public class AsyncConfig {} ```...
SpringBoot开启异步调用方法
08-25
SpringBoot 框架提供了多种方式来实现异步调用，异步调用可以提高系统的性能和响应速度。在本文中，我们将详细介绍如何使用 SpringBoot 实现异步调用，并分析异步调用的优缺点和实现细节。 一、异步调用概述 异步...
SpringBoot项目异步调用
03-28
它允许应用程序在执行一个耗时操作（如数据库查询、文件处理等）时，不阻塞主线程，从而提高系统的响应速度和并发能力。Spring Boot提供了简单易用的API和配置来实现异步方法调用，通常结合线程池来优化资源利用。 ...
详解SpringBoot中异步请求和异步调用(看完这一篇就够了)
08-26
最后，需要在异步线程中执行耗时的处理操作，并在处理完成后通知异步上下文，以便释放资源。 方式二：使用Callable方式实现异步请求 使用Callable方式实现异步请求非常简单，只需要将返回的参数包裹一层Callable...
Spring Boot 高并发：如何提高接口 TPS
回纹勾边宝相花团
04-14 5246
Spring Boot 提高接口 TPS一、@Async二、embedded tomcat 性能調优 一、@Async 启动类开启 @EnableAsync ，服务类添加 @Async 方法，化同步为异步，可一定程度提高并发。 二、embedded tomcat 性能調优 增加 Spring Boot 内置 tomcat 的线程数和连接数，可以大幅度提升并发性能。但如果该接口会调用其他系统的接口，则该接口的 TPS 会受制于对方接口的 TPS。 server.tomcat.accept-count=1000
提高接口并发量
10-30 1524
增加线程池中线程池的个数，同时需要增强硬件。
提高接口并发-异步处理任务
小学僧的博客
05-27 372
任务处理类 package com.deepblue.aivideo.biz.thread; import com.deepblue.aivideo.api.entiy.DeviceAbilityGroupRelationDto; import com.deepblue.aivideo.api.entiy.PersonFaceLog; import com.deepblue.aivideo.biz.service.PersonFaceLogService; import com.deepblue.aivi
高并发接口设计
不经意的博客
07-09 3081
场景:每秒10000-40000并发，最高将近50000并发量 一、硬件加持简单粗暴，单机视情况加内存，cpu等等，考虑加服务器做集群，或增加集群节点 二、架构选择 不会吧，不会吧，不会还有人在高并发场景下做成单体应用吧，假如某个接口并发量特别大，在不做限流的情况下是不是会把整个系统拖垮，其他功能也用不了，一个接口并发高导致服务器cpu或内存起飞，最终导致整个系统死掉。所以分布式架构是必须的，做成微服务，最坏结果也就是某个功能用不了，不影响其他功能。 我遇到过的实际场景，某业务接口并发量很高，不限流的情况下
聊聊接口性能优化的11个小技巧
Admans的专栏
07-13 891
接口性能优化对于从事后端开发的同学来说，肯定再熟悉不过了，因为它是一个跟开发语言无关的公共问题。该问题说简单也简单，说复杂也复杂。有时候，只需加个索引就能解决问题。有时候，需要做代码重构。有时候，需要增加缓存。有时候，需要引入一些中间件，比如mq。有时候，需要需要分库分表。有时候，需要拆分服务。等等……导致接口性能问题的原因千奇百怪，不同的项目不同的接口，原因可能也不一样。本文我总结了一些行之有效的，优化接口性能的办法，给有需要的朋友一个参考。接口性能优化大家第一个想到的可能是：。没错，优化索引的成本是最小
如何解决接口并发操作
HanaeNatsuki的博客
07-20 1329
1、加锁 加锁后，能很方便的解决接口重复数据的传入问题，同时会拖慢接口反应速度 2、数据库添加唯一性约束 反应很快，对数据库的特定字段添加，并对数据进行统一管理，一旦有多重业务情景，就不能灵活应对了 ...
类似火车票出票的并发处理问题汇总
stonec的专栏
10-30 2530
原始帖子：http://topic.csdn.net/t/20060809/09/4936623.html 问题要求： 类似银行转账、火车票管理如订购等:     当select出一条或多条火车票后，选择其中一条记录上做一些操作,比如购买，此时如果有同样的一个人也同时定购了此火车票（此时并发），怎么办？         select纪录   ---〉购买处理过程   --〉票数-1    
接口业务异步处理
小小坚的博客
08-13 2938
场景 比如我们在项目中的一个前端接口在每次调用的时候需要处理比较耗时且对结果不需要直接反馈的业务（比如需要多次调用第三方的http接口同步一些信息等），此时我们就需要将其设计成异步，以此来提高接口的响应速度。 处理方式 启动类 在我们的启动类上面加上开启异步的注解@EnableAsync @SpringBootApplication @EnableAsync public class TestApplication { public static void main(String[] args) {
springboot异步线程
09-14
Spring Boot提供了一种方便的方式来启用异步线程，以提高代码的并发能力[1]。下面是在Spring Boot中启用异步线程的几个步骤： 1. 配置线程池：在Spring Boot应用的配置类中，使用`@EnableAsync`注解启用异步线程，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值