API接口并发请求控制实现

已于 2024-10-14 22:14:30 修改
阅读量3.8k 收藏 6
点赞数 4
分类专栏： 系统架构 Java 文章标签： 并发 线程
于 2024-10-12 17:41:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16127313/article/details/142880145
版权

文章目录

一、问题概述

某API接口，承载某重要业务，希望控制任意时间点的并发访问数在5以内，该如何实现？

二、解决思路

解决这个问题主要有4个思路： 原子计数器和信号量以及阻塞队列 , 固定线程池。
原子计数器有2个实现：AtomicInteger、LongAdder
信号量：Semaphore
阻塞队列：ArrayBlockingQueue、LinkedBlockingQueue
固定线程池： Executors.newFixedThreadPool

单元测试代码验证

1. AtomicInteger


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import org.apache.commons.lang3.RandomUtils;
import org.junit.jupiter.api.Test;
import org.springframework.util.StopWatch;

import lombok.extern.slf4j.Slf4j;

/**
 * AomicInteger控制线程并发数
 * 
 */
@Slf4j
public class AtomicIntegerTest
{
    private AtomicInteger count = new AtomicInteger(0);
    
    /**
     * 最大并发数
     */
    private int max = 5;
    
    /**
     * 线程池方式测试
     * 
     * @throws InterruptedException
     * @see [类、类#方法、类#成员]
     */
    @Test
    public void test()
        throws InterruptedException
    {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        int id = 0;
        while (id++ < 100)
        {
            cachedThreadPool.execute(() -> runCall());
            TimeUnit.MILLISECONDS.sleep(RandomUtils.nextInt(100, 1000));
        }
        cachedThreadPool.shutdown();
        while (!cachedThreadPool.isTerminated()) // 保证任务全部执行完
        {
        }
    }
    
    private void runCall()
    {
        try
        {
            log.info("++++ 计数器自增：{}", count.incrementAndGet());
            if (count.get() > max)
            {
                log.info("✈✈✈✈✈ 请求用户过多,请稍后再试! ✈✈✈✈✈");
                return;
            }
            
            // 模拟耗时业务操作
            log.info("★★★★★★★★ 报名或抢购处理中★★★★★★★★");
            StopWatch clock = new StopWatch();
            clock.start();
            TimeUnit.MILLISECONDS.sleep(RandomUtils.nextInt(1000, 5000));
            clock.stop();
            log.info("运行 {} ms ---------------", clock.getLastTaskTimeMillis());
        }
        catch (InterruptedException e)
        {
            log.error(e.getMessage());
        }
        finally
        {
            log.info("---- 计数器自减：{}", count.decrementAndGet());
        }
    }
}

运行结果：
在这里插入图片描述

2. LongAdder


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.LongAdder;

import org.apache.commons.lang3.RandomUtils;
import org.junit.jupiter.api.Test;
import org.springframework.util.StopWatch;

import lombok.extern.slf4j.Slf4j;

/**
 * LongAdder控制线程并发数
 *
 */
@Slf4j
public class LongAdderTest
{
    private LongAdder count = new LongAdder();
    
    /**
     * 最大并发数
     */
    private int max = 5;
    
    /**
     * 线程池方式测试
     * 
     * @throws InterruptedException
     * @see [类、类#方法、类#成员]
     */
    @Test
    public void test()
        throws InterruptedException
    {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        int id = 0;
        while (id++ < 100)
        {
            cachedThreadPool.execute(() -> runCall());
            TimeUnit.MILLISECONDS.sleep(RandomUtils.nextInt(100, 1000));
        }
        cachedThreadPool.shutdown();
        while (!cachedThreadPool.isTerminated()) // 保证任务全部执行完
        {
        }
    }
    
    private void runCall()
    {
        try
        {
            count.increment();
            log.info("++++ 计数器自增：{}", count.sum());
            if (count.sum() > max)
            {
                log.info("✈✈✈✈✈ 请求用户过多,请稍后再试! ✈✈✈✈✈");
                return;
            }
            
            // 模拟耗时业务操作
            log.info("★★★★★★★★ 报名或抢购处理中★★★★★★★★");
            StopWatch clock = new StopWatch();
            clock.start();
            TimeUnit.MILLISECONDS.sleep(RandomUtils.nextInt(1000, 5000));
            clock.stop();
            log.info("运行 {} ms ---------------", clock.getLastTaskTimeMillis());
        }
        catch (InterruptedException e)
        {
            log.error(e.getMessage());
        }
        finally
        {
            count.decrement();
            log.info("---- 计数器自减：{}", count.sum());
        }
    }
}

运行结果：
在这里插入图片描述

3. Semaphore


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import org.apache.commons.lang3.RandomUtils;
import org.junit.jupiter.api.Test;
import org.springframework.util.StopWatch;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class SemaphoreTest
{
    private int max = 5;
    
    private Semaphore semaphore = new Semaphore(max, true);
    
    private AtomicInteger count = new AtomicInteger(0);
    
    /**
     * 线程池方式测试
     * 
     * @throws InterruptedException
     * @see [类、类#方法、类#成员]
     */
    @Test
    public void test()
        throws InterruptedException
    {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        int id = 0;
        while (id++ < 100)
        {
            cachedThreadPool.execute(() -> runCall());
            TimeUnit.MILLISECONDS.sleep(RandomUtils.nextInt(100, 1000));
        }
        cachedThreadPool.shutdown();
        while (!cachedThreadPool.isTerminated()) // 保证任务全部执行完
        {
        }
    }
    
    private void runCall()
    {
        try
        {
            semaphore.acquire();
            log.info("计数器自增：{}", count.incrementAndGet());
            
            // 模拟耗时业务操作
            log.info("★★★★★★★★ 报名或抢购处理中★★★★★★★★");
            StopWatch clock = new StopWatch();
            clock.start();
            TimeUnit.MILLISECONDS.sleep(RandomUtils.nextInt(1000, 5000));
            clock.stop();
            log.info("运行 {} ms ---------------", clock.getLastTaskTimeMillis());
        }
        catch (InterruptedException e)
        {
            log.error(e.getMessage());
        }
        finally
        {
            semaphore.release();
            log.info("计数器自减：{}", count.decrementAndGet());
        }
    }
}

运行结果：
在这里插入图片描述

4. BlockingQueue


import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import org.apache.commons.lang3.RandomUtils;
import org.junit.jupiter.api.Test;
import org.springframework.util.StopWatch;

import lombok.extern.slf4j.Slf4j;

/**
 * 阻塞队列控制并发<br>
 * https://www.cnblogs.com/WangHaiMing/p/8798709.html
 */
@Slf4j
public class BlockingQueueTest
{
    private int max = 5;
    
    private BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(max, true);
    // 或者 private BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>(max, true);
    
    private AtomicInteger count = new AtomicInteger(0);
    
    /**
     * 线程池方式测试
     * 
     * @throws InterruptedException
     * @see [类、类#方法、类#成员]
     */
    @Test
    public void test()
        throws InterruptedException
    {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        int id = 0;
        while (id++ < 100)
        {
            cachedThreadPool.execute(() -> runCall());
            TimeUnit.MILLISECONDS.sleep(RandomUtils.nextInt(100, 1000));
        }
        cachedThreadPool.shutdown();
        while (!cachedThreadPool.isTerminated()) // 保证任务全部执行完
        {
        }
    }
    
    private void runCall()
    {
        try
        {
            log.info("计数器自增：{}", count.incrementAndGet());
            if (!blockingQueue.offer(""))
            {
                log.info("✈✈✈✈✈ 请求用户过多,请稍后再试! ✈✈✈✈✈");
                return;
            }
            
            // 模拟耗时业务操作
            log.info("★★★★★★★★ 报名或抢购处理中★★★★★★★★");
            StopWatch clock = new StopWatch();
            clock.start();
            TimeUnit.MILLISECONDS.sleep(RandomUtils.nextInt(1000, 5000));
            clock.stop();
            log.info("运行 {} ms ---------------", clock.getLastTaskTimeMillis());
            blockingQueue.poll();
        }
        catch (InterruptedException e)
        {
            log.error(e.getMessage());
        }
        finally
        {
            log.info("计数器自减：{}", count.decrementAndGet());
        }
    }
}

运行结果：
在这里插入图片描述

5. Executors.newFixedThreadPool


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import org.apache.commons.lang3.RandomUtils;
import org.junit.jupiter.api.Test;
import org.springframework.util.StopWatch;

import lombok.extern.slf4j.Slf4j;

/**
 * 固定长度线程池控制并发
 */
@Slf4j
public class FixedThreadPoolTest
{
    private int max = 5;
    
    private AtomicInteger count = new AtomicInteger(0);
    
    /**
     * 线程池方式测试
     * 
     * @throws InterruptedException
     * @see [类、类#方法、类#成员]
     */
    @Test
    public void test()
        throws InterruptedException
    {
        ExecutorService executorService = Executors.newFixedThreadPool(max);
        int id = 0;
        while (id++ < 100)
        {
            executorService.execute(() -> runCall());
            TimeUnit.MILLISECONDS.sleep(RandomUtils.nextInt(100, 1000));
        }
        executorService.shutdown();
        while (!executorService.isTerminated()) // 保证任务全部执行完
        {
        }
    }
    
    /**
     * 验证方法: sum('报名或抢购处理中')与sum('请求用户过多,请稍后再试')日志条数为100
     */
    private void runCall()
    {
        try
        {
            log.info("计数器自增：{}", count.incrementAndGet());
            
            // 模拟耗时业务操作
            log.info("★★★★★★★★ 报名或抢购处理中★★★★★★★★");
            StopWatch clock = new StopWatch();
            clock.start();
            TimeUnit.MILLISECONDS.sleep(RandomUtils.nextInt(1000, 5000));
            clock.stop();
            log.info("运行 {} ms ---------------", clock.getLastTaskTimeMillis());
        }
        catch (InterruptedException e)
        {
            log.error(e.getMessage());
        }
        finally
        {
            log.info("计数器自减：{}", count.decrementAndGet());
        }
    }
}

运行结果：
在这里插入图片描述

6. 实现区别

对比原子计数器和信号量的实现，我们可以发现信号量Semaphore一旦许可不够会导致线程阻塞，Executors.newFixedThreadPool也类似，其他实现，如原子计数器一旦达到最大线程并发数，可以快速失败，立即返回友好的提示信息。

三、API接口并发控制

1. 核心源码


import java.util.concurrent.Callable;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.LongAdder;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.fly.demo.JsonResult;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Api(tags = "接口并发控制")
@RestController
@RequestMapping(value = "/both", produces = "application/json; charset=utf-8")
public class ConcurrentController
{
    /**
     * 最大并发数
     */
    private int max = 5;
    
    /***************** 注意：不可共用计数器！！！ ******************/
    
    AtomicInteger count1 = new AtomicInteger(0);
    
    LongAdder count2 = new LongAdder();
    
    LongAdder count3 = new LongAdder();
    
    Semaphore semaphore = new Semaphore(max, true);
    
    @ApiOperation("并发测试Atomic")
    @GetMapping("/query/atomic")
    public JsonResult<?> queryAtomic()
    {
        try
        {
            log.info("计数器自增：{}", count1.incrementAndGet());
            if (count1.get() > max)
            {
                log.info("✈✈✈✈✈ 请求用户过多✈✈✈✈✈");
                return JsonResult.error("请求用户过多,请稍后再试!");
            }
            log.info("业务处理开始......");
            TimeUnit.SECONDS.sleep(10);
        }
        catch (InterruptedException e)
        {
            log.error(e.getMessage());
        }
        finally
        {
            log.info("计数器自减：{}", count1.decrementAndGet());
        }
        return JsonResult.success();
    }
    
    @ApiOperation("并发测试LongAdder")
    @GetMapping("/query/longAdder")
    public JsonResult<?> queryLongAdder()
    {
        try
        {
            count2.increment();
            log.info("计数器自增：{}", count2.sum());
            if (count2.sum() > max)
            {
                log.info("✈✈✈✈✈ 请求用户过多,计数：{} ✈✈✈✈✈", count2.sum());
                return JsonResult.error("请求用户过多,请稍后再试!");
            }
            log.info("业务处理开始......");
            TimeUnit.SECONDS.sleep(10);
        }
        catch (InterruptedException e)
        {
            log.error(e.getMessage());
        }
        finally
        {
            count2.decrement();
            log.info("计数器自减：{}", count2.sum());
        }
        return JsonResult.success();
    }
    
    // 仅用于Semaphore中计数
    private AtomicInteger count = new AtomicInteger(0);
    
    @ApiOperation("并发测试Semaphore")
    @GetMapping("/query/semaphore")
    public JsonResult<?> querySemaphore()
    {
        try
        {
            // 一旦许可不够,线程阻塞
            semaphore.acquire();
            log.info("计数器自增：{}", count.incrementAndGet());
            
            log.info("业务处理开始......");
            TimeUnit.SECONDS.sleep(10);
        }
        catch (InterruptedException e)
        {
            log.error(e.getMessage());
        }
        finally
        {
            semaphore.release();
            log.info("计数器自减：{}", count.decrementAndGet());
        }
        return JsonResult.success();
    }
    
    @ApiOperation("并发测试InCallable")
    @GetMapping("/query/callable")
    public Callable<JsonResult<?>> callable()
    {
        return () -> {
            try
            {
                count3.increment();
                log.info("计数器自增：{}", count3.sum());
                if (count3.sum() > max)
                {
                    log.info("✈✈✈✈✈ 请求用户过多,计数：{} ✈✈✈✈✈", count3.sum());
                    return JsonResult.error("请求用户过多,请稍后再试!");
                }
                log.info("业务处理开始......");
                TimeUnit.SECONDS.sleep(10);
            }
            catch (InterruptedException e)
            {
                log.error(e.getMessage());
            }
            finally
            {
                count3.decrement();
                log.info("计数器自减：{}", count3.sum());
            }
            return JsonResult.success();
        };
    }
}

2. 源码放送

https://gitcode.com/00fly/springboot-demo.git

git clone https://gitcode.com/00fly/springboot-demo.git

有任何问题和建议，都可以向我提问讨论,大家一起进步，谢谢!

-over-

爱码少年 00fly.online
关注
专栏目录
大用户并发系统API设计心得
feiniao198751的专栏
05-11 4532
所谓的大并发，是指QPS，大于1000,日活跃用户量在千万级别的业务系统。 缓存就是其中的重中之重，没有缓存，分分钟数据库无法抗住系统压力，直接挂了，从而影响别的业务响应。 1、把这个API接口的所有数据库请求结果都缓存起来，当然缓存需要设计过期时间，在缓存存在的情况下，数据库的请求就大大减少，只有当过期的时候才会去请求一遍数据库，采用异步缓存，缓存结果是定期更新的，不会出现在过期临界点上的响
c#中并发请求api接口_在一个宁静的api中处理并发请求
weixin_26716079的博客
08-30 2209
c#中并发请求api接口Imagine the following scenario:想象以下情况： User A requests resource 1 via a GET endpoint 用户A通过GET端点请求资源1 User B requests resource 1 via a GET endpoint 用户B通过GET端点请求资源1 User A makes changes on r...
接口并发请求控制
cwjxyp的博客
07-27 1053
Gmail开发人员发现IE里面有个对象来请求数据时，，所以使用这个特性，进行网络数据请求，这就是AJAX的由来。AJAX不是一个单词，他的全称是，就是异步的JavaScript和XML，它是一套用于创建快速动态网页的技术标准，使用步骤如下：创建异步对象设置请求参数，包括请求的方法和URL等发送请求注册事件，事件状态变更会及时响应监听在监听里面获取并处理返回数据所以AJAX的核心就是。
高并发的API请求有哪些注意事项？
最新发布
YONG823_API的博客
11-16 820
高并发的API请求处理是一个复杂且持续优化的过程。通过理解性能瓶颈、优化API设计、服务器端优化、加强API调用安全、应用高并发处理技术和实际案例与代码示例，我们可以显著提升API的性能和稳定性。然而，这仅仅是一个开始，随着技术和威胁的变化，我们还需要不断更新和升级API的安全措施，确保系统始终能够为用户提供快速、稳定和安全的服务。希望本文能够为开发者在处理高并发API请求时提供一些有益的参考和启示。
分布式、多线程、高并发都不懂，拿什么去跳槽
Java笔记虾
10-08 3万+
当提起这三个词的时候，是不是很多人都认为分布式=高并发=多线程？当面试官问到高并发系统可以采用哪些手段来解决，或者被问到分布式系统如何解决一致性的问题，是不是一脸懵逼？确...
高并发之API接口限流
热门推荐
zrg523的专栏
08-29 5万+
   在开发高并发系统时有三把利器用来保护系统：缓存、降级和限流 缓存 缓存的目的是提升系统访问速度和增大系统处理容量 降级 降级是当服务出现问题或者影响到核心流程时，需要暂时屏蔽掉，待高峰或者问题解决后再打开 限流 限流的目的是通过对并发访问/请求进行限速，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理 问题描述   　　某天A君突然...
WEBAPI多线程并发测试工具
09-18
Web API通常指的是应用程序接口，它们允许不同的服务之间进行通信，以实现数据交换和功能整合。多线程并发测试则是验证在多个线程同时访问API时，系统的性能、稳定性和正确性。 描述中的“WEB API 多线程并发测试...
C#实现快递api接口调用方法
09-03
具体的请求参数构造和HTTP请求实现没有在提供的代码中给出，但通常会使用如`HttpClient`类来发送POST请求，携带必要的参数（如uid、key、id和order）到指定的sync_url。请求的响应会被反序列化成`SyncResponseEntity...
Python并发请求下限制QPS(每秒查询率)的实现代码
09-16
本篇将详细介绍如何在Python并发请求环境下限制QPS的实现方法。 首先，QPS限制对于那些提供服务的服务器至关重要，因为它可以防止恶意或无意的大量请求导致服务器过载。在Python中，我们可以使用不同的策略来实现...
web压测高并发接口测试工具
08-12
一款定制的压测工具, 对webapi webserver 等一些借口进行压测 , 可以自定义并发数量.
Java并发API案例分析之并发设计原理
陆海潘江的博客
01-15 3785
并发、并行、同步、锁、线程安全……这一篇我记录了学习并发设计原理的关键知识，还有一些常用重要的Java并发编程API，学习一些关于并发程序设计的原理，弄懂来龙去脉，相对更加深入地理解并这部分知识。在学习理论知识后，对这个部分有了更深层的理解！
REST API 并发控制
datiancai2008的专栏
09-17 8108
对请求做并发限制是在后端处理能力有限的情况下，防止因某单一用户大量请求将服务器资源暂满导致无法响应其他用户请求的安全保护措施。常见的并发限制方法就是限制用户在某一段时间内的请求数目，如100r/s，即限制用户1s内最多请求100次，超过就拒绝访问。下面介绍几种常见并发控制的实现方法。1. memcache/redismemcache和redis等nosql的提供了以下两个特性，可以很好的支持对请求进
并发 API
花开不合阳春暮
01-10 307
java.lang.Thread static void sleep(long millis) 休眠给定的毫秒数 Thread(Runnable target) 构造一个新线程，用于调用给定目标的run()方法 void start() 启动这个线程，将引发调用run()方法。这个方法将立即返回，并且新线程将并发运行。 void run() 调用关联Runnable的run方法 ...
Java高并发秒杀API(四)之高并发优化
不积跬步，无以至千里
10-06 3万+
Java高并发秒杀API(四)之高并发优化1. 高并发优化分析 关于并发 并发性上不去是因为当多个线程同时访问一行数据时，产生了事务，因此产生写锁，每当一个获取了事务的线程把锁释放，另一个排队线程才能拿到写锁，QPS(Query Per Second每秒查询率)和事务执行的时间有密切关系，事务执行时间越短，并发性越高，这也是要将费时的I/O操作移出事务的原因。 在本项目中高并发发生在哪？ 在
四、高并发秒杀API之Web层设计与实现
此处省略三千字
08-14 3539
Web层涉及到的技术： 前端交互：页面之间的交互和交互细节 Restful：前端设计接口之间的一种常用的规范 Spring MVC：框架整合，以及如何应用设计和实现Restful接口 Bootstrap和jquery：前者负责页面布局和样式控制，后者负责交互的实现。  1 前端分析与设计 1.1 前端交互设计部分 前端页面流程：
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值