高并发之API接口限流

最新推荐文章于 2024-09-27 11:22:10 发布
最新推荐文章于 2024-09-27 11:22:10 发布
阅读量883 收藏 1
点赞数
分类专栏： java 文章标签： java
原文链接：https://blog.csdn.net/zrg523/article/details/82185088?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-10.vipsorttest&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommen
版权
本文介绍了在开发高并发系统中，缓存提升访问速度，降级应对服务问题，限流保护系统免受过度压力的三种关键策略。通过实例和Google RateLimiter，讲解了限流技术在并发数量控制、访问速率限制和时间窗口内的请求控制的应用。
摘要由CSDN通过智能技术生成

   在开发高并发系统时有三把利器用来保护系统：缓存、降级和限流

  • 缓存 缓存的目的是提升系统访问速度和增大系统处理容量
  • 降级 降级是当服务出现问题或者影响到核心流程时，需要暂时屏蔽掉，待高峰或者问题解决后再打开
  • 限流 限流的目的是通过对并发访问/请求进行限速，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理

问题描述  

　　某天A君突然发现自己的接口请求量突然涨到之前的10倍，没多久该接口几乎不可使用，并引发连锁反应导致整个系统崩溃。如何应对这种情况呢？生活给了我们答案：比如老式电闸都安装了保险丝，一旦有人使用超大功率的设备，保险丝就会烧断以保护各个电器不被强电流给烧坏。同理我们的接口也需要安装上“保险丝”，以防止非预期的请求对系统压力过大而引起的系统瘫痪，当流量过大时，可以采取拒绝或者引流等机制。 

         缓存的目的是提升系统访问速度和增大系统能处理的容量，可谓是抗高并发流量的银弹；而降级是当服务出问题或者影响到核心流程的性能则需要暂时屏蔽掉，待高峰或者问题解决后再打开；而有些场景并不能用缓存和降级来解决，比如稀缺资源（秒杀、抢购）、写服务（如评论、下单）、频繁的复杂查询（评论的最后几页），因此需有一种手段来限制这些场景的并发/请求量，即限流。

        系统在设计之初就会有一个预估容量，长时间超过系统能承受的TPS/QPS阈值，系统可能会被压垮，最终导致整个服务不够用。为了避免这种情况，我们就需要对接口请求进行限流。 

       限流的目的是通过对并发访问请求进行限速或者一个时间窗口内的的请求数量进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待。 

        一般开发高并发系统常见的限流模式有控制并发和控制速率，一个是限制并发的总数量（比如数据库连接池、线程池），一个是限制并发访问的速率（如nginx的limit_conn模块，用来限制瞬时并发连接数），另外还可以限制单位时间窗口内的请求数量（如Guava的RateLimiter、nginx的limit_req模块，限制每秒的平均速率）。其他还有如限制远程接口调用速率、限制MQ的消费速率。另外还可以根据网络连接数、网络流量、CPU或内存负载等来限流。

相关概念： 
PV:

page view 页面总访问量，每刷新一次记录一次。

UV:

unique view 客户端主机访问，指一天内相同IP的访问记为1次。

QPS:

query per second,即每秒访问量。qps很大程度上代表了系统的繁忙度，没次请求可能存在多次的磁盘io，网络请求，多个cpu时间片，一旦qps超过了预先设置的阀值，可以考量扩容增加服务器，避免访问量过大导致的宕机。

RT:

response time,每次请求的响应时间,直接决定用户体验性。

 

本文主要介绍应用级限流方法，分布式限流、流量入口限流（接入层如NGINX limit_conn和limit_req 模块）。

应用级限流

一、控制并发数量

属于一种较常见的限流手段，在实际应用中可以通过信号量机制（如Java中的Semaphore）来实现。 操作系统的信号量是个很重要的概念，Java 并发库 的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。

举个例子，我们对外提供一个服务接口，允许最大并发数为10，代码实现如下：

public class DubboService {
 
    private final Semaphore permit = new Semaphore(10, true);
 
    public void process(){
 
        try{
            permit.acquire();
            //业务逻辑处理
 
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            permit.release();
        }
    }
}

      在以上代码中，虽然有30个线程在执行，但是只允许10个并发的执行。Semaphore的构造方法Semaphore(int permits) 接受一个整型的数字，表示可用的许可证数量。Semaphore(10)表示允许10个线程获取许可证，也就是最大并发数是10。Semaphore的用法也很简单，首先线程使用Semaphore的acquire()获取一个许可证，使用完之后调用release()归还许可证，还可以用tryAcquire()方法尝试获取许可证，信号量的本质是控制某个资源可被同时访问的个数，在一定程度上可以控制某资源的访问频率，但不能精确控制，控制访问频率的模式见下文描述。

二、控制访问速率

   在工程实践中，常见的是使用令牌桶算法来实现这种模式，常用的限流算法有两种：漏桶算法和令牌桶算法。

  • 漏桶算法

漏桶算法思路很简单，水（请求）先进入到漏桶里，漏桶以一定的速度出水，当水流入速度过大会直接溢出，可以看出漏桶算法能强行限制数据的传输速率。

img

       对于很多应用场景来说，除了要求能够限制数据的平均传输速率外，还要求允许某种程度的突发传输。这时候漏桶算法可能就不合适了，令牌桶算法更为适合。

  • 令牌桶算法

如图所示，令牌桶算法的原理是系统会以一个恒定的速度往桶里放入令牌，而如果请求需要被处理，则需要先从桶里获取一个令牌，当桶里没有令牌可取时，则拒绝服务，令牌桶算法通过发放令牌，根据令牌的rate频率做请求频率限制，容量限制等。

img

在Wikipedia上，令牌桶算法是这么描述的：

  1. 每过1/r秒桶中增加一个令牌。
  2. 桶中最多存放b个令牌，如果桶满了，新放入的令牌会被丢弃。
  3. 当一个n字节的数据包到达时，消耗n个令牌，然后发送该数据包。
  4. 如果桶中可用令牌小于n，则该数据包将被缓存或丢弃。

       令牌桶控制的是一个时间窗口内通过的数据量，在API层面我们常说的QPS、TPS，正好是一个时间窗口内的请求量或者事务量，只不过时间窗口限定在1s罢了。以一个恒定的速度往桶里放入令牌，而如果请求需要被处理，则需要先从桶里获取一个令牌，当桶里没有令牌可取时，则拒绝服务。令牌桶的另外一个好处是可以方便的改变速度，一旦需要提高速率，则按需提高放入桶中的令牌的速率。

       在我们的工程实践中，通常使用Google开源工具包Guava提供的限流工具类RateLimiter来实现控制速率，该类基于令牌桶算法来完成限流，非常易于使用，而且非常高效。如我们不希望每秒的任务提交超过1个

  public static void main(String[] args) {
    String start = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
    RateLimiter limiter = RateLimiter.create(1.0); // 这里的1表示每秒允许处理的量为1个
    for (int i = 1; i <= 10; i++) {
      double waitTime = limiter.acquire(i);// 请求RateLimiter, 超过permits会被阻塞
      System.out.println("cutTime=" + System.currentTimeMillis() + " call execute:" + i + " waitTime:" + waitTime);
    }
    String end = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
    System.out.println("start time:" + start);
    System.out.println("end time:" + end);
  }

        首先通过RateLimiter.create(1.0);创建一个限流器，参数代表每秒生成的令牌数，通过limiter.acquire(i);来以阻塞的方式获取令牌，令牌桶算法允许一定程度的突发（允许消费未来的令牌），所以可以一次性消费i个令牌；当然也可以通过tryAcquire(int permits, long timeout, TimeUnit unit)来设置等待超时时间的方式获取令牌，如果超timeout为0，则代表非阻塞，获取不到立即返回，支持阻塞或可超时的令牌消费。

从输出来看，RateLimiter支持预消费，比如在acquire(5)时，等待时间是4秒，是上一个获取令牌时预消费了3个两排，固需要等待3*1秒，然后又预消费了5个令牌，以此类推。

        RateLimiter通过限制后面请求的等待时间，来支持一定程度的突发请求(预消费)，在使用过程中需要注意这一点，Guava有两种限流模式，一种为稳定模式(SmoothBursty:令牌生成速度恒定，平滑突发限流)，一种为渐进模式(SmoothWarmingUp:令牌生成速度缓慢提升直到维持在一个稳定值，平滑预热限流) 两种模式实现思路类似，主要区别在等待时间的计算上。

  • SmoothBursty 模式：RateLimiter limiter = RateLimiter.create(5);
    RateLimiter.create(5)表示桶容量为5且每秒新增5个令牌，即每隔200毫秒新增一个令牌；limiter.acquire()表示消费一个令牌，如果当前桶中有足够令牌则成功（返回值为0），如果桶中没有令牌则暂停一段时间，比如发令牌间隔是200毫秒，则等待200毫秒后再去消费令牌，这种实现将突发请求速率平均为了固定请求速率。
  • SmoothWarmingUp模式：RateLimiter limiter = RateLimiter.create(5,1000, TimeUnit.MILLISECONDS);
  • 创建方式：RateLimiter.create(doublepermitsPerSecond, long warmupPeriod, TimeUnit unit)，permitsPerSecond表示每秒新增的令牌数，warmupPeriod表示在从冷启动速率过渡到平均速率的时间间隔。速率是梯形上升速率的，也就是说冷启动时会以一个比较大的速率慢慢到平均速率；然后趋于平均速率（梯形下降到平均速率）。可以通过调节warmupPeriod参数实现一开始就是平滑固定速率。

放在Controller中用Jemter压测

 

注：RateLimiter控制的是速率，Samephore控制的是并发量。RateLimiter的原理就是令牌桶，它主要由许可发出的速率来定义，如果没有额外的配置，许可证将按每秒许可证规定的固定速度分配，许可将被平滑地分发，若请求超过permitsPerSecond则RateLimiter按照每秒 1/permitsPerSecond 的速率释放许可。注意:RateLimiter适用于单体应用，且RateLimiter不保证公平性访问。

使用上述方式使用RateLimiter的方式不够优雅，自定义注解+AOP的方式实现(适用于单体应用)，详细见下面代码：

自定义注解：

import java.lang.annotation.*;
 
/**
 * 自定义注解可以不包含属性，成为一个标识注解
 */
@Inherited
@Documented
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimitAspect {
   
}

自定义切面类

import com.google.common.util.concurrent.RateLimiter;
import com.test.cn.springbootdemo.util.ResultUtil;
import net.sf.json.JSONObject;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
 
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
 
@Component
@Scope
@Aspect
public class RateLimitAop {
 
    @Autowired
    private HttpServletResponse response;
 
    private RateLimiter rateLimiter = RateLimiter.create(5.0); //比如说，我这里设置"并发数"为5
 
    @Pointcut("@annotation(com.test.cn.springbootdemo.aspect.RateLimitAspect)")
    public void serviceLimit() {
 
    }
 
    @Around("serviceLimit()")
    public Object around(ProceedingJoinPoint joinPoint) {
        Boolean flag = rateLimiter.tryAcquire();
        Object obj = null;
        try {
            if (flag) {
                obj = joinPoint.proceed();
            }else{
                String result = JSONObject.fromObject(ResultUtil.success1(100, "failure")).toString();
                output(response, result);
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("flag=" + flag + ",obj=" + obj);
        return obj;
    }
    
    public void output(HttpServletResponse response, String msg) throws IOException {
        response.setContentType("application/json;charset=UTF-8");
        ServletOutputStream outputStream = null;
        try {
            outputStream = response.getOutputStream();
            outputStream.write(msg.getBytes("UTF-8"));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            outputStream.flush();
            outputStream.close();
        }
    }
}

测试controller

import com.test.cn.springbootdemo.aspect.RateLimitAspect;
import com.test.cn.springbootdemo.util.ResultUtil;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
 
 
@Controller
public class TestController {
 
    @ResponseBody
    @RateLimitAspect
    @RequestMapping("/test")
    public String test(){
        return ResultUtil.success1(1001, "success").toString();
    }

压测结果：

三、控制单位时间窗口内请求数

某些场景下，我们想限制某个接口或服务 每秒/每分钟/每天 的请求次数或调用次数。例如限制服务每秒的调用次数为50，实现如下：

private LoadingCache<Long, AtomicLong> counter =
            CacheBuilder.newBuilder()
                    .expireAfterWrite(2, TimeUnit.SECONDS)
                    .build(new CacheLoader<Long, AtomicLong>() {
                        @Override
                        public AtomicLong load(Long seconds) throws Exception {
                            return new AtomicLong(0);
                        }
                    });
 
    public static long permit = 50;
 
    public ResponseEntity getData() throws ExecutionException {
 
        //得到当前秒
        long currentSeconds = System.currentTimeMillis() / 1000;
        if(counter.get(currentSeconds).incrementAndGet() > permit) {
            return ResponseEntity.builder().code(404).msg("访问速率过快").build();
        }
        //业务处理
 
    }

          到此应用级限流的一些方法就介绍完了。假设将应用部署到多台机器，应用级限流方式只是单应用内的请求限流，不能进行全局限流。因此我们需要分布式限流和接入层限流来解决这个问题。

分布式限流

  • 自定义注解+拦截器+Redis实现限流 (单体和分布式均适用，全局限流)

自定义注解：

@Inherited
@Documented
@Target({ElementType.FIELD,ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface AccessLimit {
 
    int limit() default 5;  
 
    int sec() default 5;
}

拦截器：

public class AccessLimitInterceptor implements HandlerInterceptor {
 
    @Autowired
    private RedisTemplate<String, Integer> redisTemplate;  //使用RedisTemplate操作redis
 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            if (!method.isAnnotationPresent(AccessLimit.class)) {
                return true;
            }
            AccessLimit accessLimit = method.getAnnotation(AccessLimit.class);
            if (accessLimit == null) {
                return true;
            }
            int limit = accessLimit.limit();
            int sec = accessLimit.sec();
            String key = IPUtil.getIpAddr(request) + request.getRequestURI();
            Integer maxLimit = redisTemplate.opsForValue().get(key);
            if (maxLimit == null) {
                redisTemplate.opsForValue().set(key, 1, sec, TimeUnit.SECONDS);  //set时一定要加过期时间
            } else if (maxLimit < limit) {
                redisTemplate.opsForValue().set(key, maxLimit + 1, sec, TimeUnit.SECONDS);
            } else {
                output(response, "请求太频繁!");
                return false;
            }
        }
        return true;
    }
 
    public void output(HttpServletResponse response, String msg) throws IOException {
        response.setContentType("application/json;charset=UTF-8");
        ServletOutputStream outputStream = null;
        try {
            outputStream = response.getOutputStream();
            outputStream.write(msg.getBytes("UTF-8"));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            outputStream.flush();
            outputStream.close();
        }
    }
 
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
 
    }
 
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
 
    }
}

controller:

@Controller
@RequestMapping("/activity")
public class AopController {
    @ResponseBody
    @RequestMapping("/seckill")
    @AccessLimit(limit = 4,sec = 10)  //加上自定义注解即可
    public String test (HttpServletRequest request,@RequestParam(value = "username",required = false) String userName){
        //TODO somethings……
        return   "hello world !";
    }
}

配置文件：

/*springmvc的配置文件中加入自定义拦截器*/
<mvc:interceptors>
   <mvc:interceptor>
      <mvc:mapping path="/**"/>
      <bean class="com.pptv.activityapi.controller.pointsmall.AccessLimitInterceptor"/>
   </mvc:interceptor>
</mvc:interceptors>

访问效果如下，10s内访问接口超过4次以上就过滤请求，原理和计数器算法类似：

接入层限流

主要介绍nginx 限流，采用漏桶算法。

限制原理:可一句话概括为：“根据客户端特征，限制其访问频率”，客户端特征主要指IP、UserAgent等。使用IP比UserAgent更可靠，因为IP无法造假，UserAgent可随意伪造。

用limit_req模块来限制基于IP请求的访问频率：
http://nginx.org/en/docs/http/ngx_http_limit_req_module.html
也可以用tengine中的增强版：
http://tengine.taobao.org/document_cn/http_limit_req_cn.html
 

1.并发数和连接数控制的配置：

nginx http配置：
    #请求数量控制，每秒20个
    limit_req_zone $binary_remote_addr zone=one:10m rate=20r/s;
    #并发限制30个
    limit_conn_zone $binary_remote_addr zone=addr:10m;
 
    server块配置
    limit_req zone=one burst=5;
    limit_conn addr 30;

2. ngx_http_limit_conn_module 可以用来限制单个IP的连接数：

ngx_http_limit_conn_module模块可以按照定义的键限定每个键值的连接数。可以设定单一 IP 来源的连接数。

并不是所有的连接都会被模块计数；只有那些正在被处理的请求（这些请求的头信息已被完全读入）所在的连接才会被计数。

http {
    limit_conn_zone $binary_remote_addr zone=addr:10m;
    ...
    server {
        ...
        location /download/ {
            limit_conn addr 1;
        }

参考资料：
1、https://blog.csdn.net/zrg523/article/details/82185088?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-10.vipsorttest&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-10.vipsorttest 20210908
2、https://blog.csdn.net/fanrenxiang/article/details/80683378 20210908
3、https://blog.csdn.net/top_code/article/details/53242262 20210908
4、https://blog.csdn.net/u010889390/article/details/82151903 20210908

JohnieLi
关注
专栏目录
python调用接口限流_高并发之API接口限流
weixin_39611008的博客
12-05 1498
在开发高并发系统时有三把利器用来保护系统：缓存、降级和限流缓存的目的是提升系统访问速度和增大系统处理容量降级是当服务出现问题或者影响到核心流程时，需要暂时屏蔽掉，待高峰或者问题解决后再打开限流的目的是通过对并发访问/请求进行限速，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理某天A君突然发现自己的接口请求量突然涨到之前的10倍，没多久该接口几乎...
高并发秒杀项目——API接口文档
Zz_xiaohuihui_Hh的博客
06-05 484
高并发秒杀项目——使用swagger工具自动生成API接口文档swagger工具搭建swagger集成swagger swagger工具 Swagger是一款RESTFUL接口的文档在线自动生成+功能测试功能软件。Swagger是一个规范和完整的框架,用于生成、描述、调用和可视化RESTful风格的Web服务。目标是使客户端和文件系统作为服务器以同样的速度来更新文件的方法,参数和模型紧密集成到服务器。 搭建swagger 加入依赖 <!--swagger依赖--> <dependency&
PHP是如何对API进行限流的
weixin_40736245的博客
10-28 675
PHP是如何对API进行限流的## 标题 什么是接口限流 那么什么是限流呢？顾名思义，限流就是限制流量，包括并发的流量和一定时间内的总流量，就像你宽带包了1个G的流量，用完了就没了，所以控制你的使用频率和单次使用的总消耗。 通过限流，我们可以很好地控制系统的qps，从而达到保护系统或者接口服务器稳定的目的。 接口限流的常用算法 计数器法 计数器法是限流算法里最简单也是最容易实现的一种算法。 比如我们规定，对于A接口来说，我们1分钟的访问次数不能超过100个。那么我们可以这么做：在一开始的时候，我们可以设置一
fastapi接口限速：fastapi-limiter
最新发布
qq_39409633的博客
09-27 837
fastapi-limiter 是一个轻量级、易于集成的库，专为FastAPI设计，用于实现基于令牌桶算法（Token Bucket）的速率限制。此项目由 Long Wang 开发，并且持续维护，旨在提供一个简单而强大的方式来控制应用程序的访问速度。
分布式、多线程、高并发都不懂，拿什么去跳槽
热门推荐
Java笔记虾
10-08 3万+
当提起这三个词的时候，是不是很多人都认为分布式=高并发=多线程？当面试官问到高并发系统可以采用哪些手段来解决，或者被问到分布式系统如何解决一致性的问题，是不是一脸懵逼？确...
【SpringBoot框架篇】10.API接口限流实战
皓亮君的博客
05-21 1万+
文章目录简介限流算法漏桶算法令牌桶算法基于guava的RateLimiter实现引入依赖自定义注解自定义切面类编写web接口压测 简介 对接口限流的目的是通过对并发访问/请求进行限速，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理 限流算法 常用的限流算法由：楼桶算法和令牌桶算法。 漏桶算法 漏桶(Leaky Bucket)算法思路很简单,水(请求)先进入到漏桶里,漏桶以一定的速度出水(接口有响应速率),当水流入速度过大会直接溢出(访问频率超过接口响应速
高并发之API接口，分布式，防刷限流
KHOST的博客
04-03 2203
在开发分布式高并发系统时有三把利器用来保护系统：缓存、降级、限流 缓存 缓存的目的是提升系统访问速度和增大系统处理容量 降级 降级是当服务出现问题或者影响到核心流程时，需要暂时屏蔽掉，待高峰或者问题解决后再打开 限流 限流的目的是通过对并发访问/请求进行限速，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理 问题描述 1、某天A君...
高并发API限流策略
youbo_sun的专栏
03-28 859
高并发系统常用策略 缓存：缓存的目的是提升系统访问速度和增大系统处理容。 降级：降级是当服务出现问题或者影响到核心流程时，需要暂时屏蔽掉，待高峰或者问题解决后再打开。 限流：限流的目的是通过对并发访问量限制，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理。 分流：分流是为了将流量分发到多个服务进行处理，以便总体可以支撑巨大流量。 限流常...
ASP.NET Core Web API 接口限流
xxxzzzqqq_的博客
03-11 584
如果并发用户数，超出限制数，那么超出的用户请求失败，并提示"当前进行XXX查询的用户太多，请稍后再试"。简单来说，当传单个人员时，接口耗时很短，当传多个人员时，一般人员会较多，接口耗时较长，一般耗时几秒。当传多个人员时，并发量高时，接口的耗时就很长了，比如100个用户并发请求，耗时可长达几十秒，甚至1分钟。测试的所有接口、所有查询参数条件的调用，耗时稳定，大量并发时，不会出现接口耗时几十秒甚至1分钟的情况。测试三个接口，一个是触发限流的A接口，一个是未触发限流的A接口，一个是未被限流的B接口。
Spring Cloud Gateway 原生支持接口限流该怎么玩
weixin_34293911的博客
07-01 796
关于pig： 基于Spring Cloud、oAuth2.0开发基于Vue前后分离的开发平台，支持账号、短信、SSO等多种登录，提供配套视频开发教程。 码云地址：https://gitee.com/log4j/pig 关于 Spring Cloud Gateway SpringCloudGateway是Spring官方基于Spring ...
API接口限流
nuoWei_SenLin的博客
10-15 990
嗨，大家好！今天给大家分享一个高并发系统中必备的技能——限流。 在正式开始之前我想问问大家，身为程序员的大家，在周一到周五早上上班进地铁站的时候，有没有见过类似这样的场景？ 同样，在互联网行业中，也存在这样得场景，我们把它称为——限流，为什么要限流呢，原因如下： 在系统上线初期，用户量和访问量不大得时候，一般部署几台应用服务器，数据库做一个读写分离就基本上抗得住，但随着时间的推移，业务的发展，用户量和日活得增加，系统所承受的压力越来越大，我么都知道，应用服务器扩容很方便，但数据库扩容就有些麻.
api接口限流方案——（漏桶与令牌桶）
General_zy的博客
02-16 2163
redis操作时单线程的，平常如果想要redis原子性操作的话，可以使用incrBy()和decrBy()方法进行原子性的加减，但是对于事务性的逻辑操作，没有办法实现原子性，Redis 使用单个 Lua 解释器去运行所有脚本，当某个脚本正在运行的时候，不会有其他脚本或 Redis 命令被执行，因此，lua脚本需要运行的使用比较快，不会妨碍其它lua脚本执行。需要注意的是，匿名用户的限流策略可能会相对容易被绕过，因此在设计限流策略时，需要权衡安全性和用户体验，并考虑到可能的滥用情况。
保卫你的API：深入了解接口限流
todoitbo的博客
10-19 785
接口限流，滑动窗口算法，算法
API 接口在指定时间内限流
java肥猫
08-03 403
前言 在请求的时候服务端通过redis记录每个ip在指定时间内请求的次数，如果在特定时间内超过限制次数，抛出异常，给前端返回响应信息。 本文为参考其他博客，由于没有及时保存原文章地址，所以无法放至原文连接，如原作者看到此篇文章，可以告知本人，一定及时添加原文地址，再次感谢原文博主。 自定义注解 import java.lang.annotation.*; /** * 在 second 秒内，最大只能请求 maxCount 次，默认一秒30次 */ @Documented @Inherited @Tar
Java API限流
wuzhicheng123456的专栏
07-23 387
令牌桶算法 http://blog.didispace.com/spring-boot-request-limit/ 对于令牌桶的代码实现，可以直接使用Guava包中的RateLimiter。 public class TestRateLimiter { static RateLimiter limiter = RateLimiter.create(2.0) ; public static...
Java自定义注解实现接口限流实战演示
接口限流是指对某一接口的访问频率进行限制，以防止因高并发访问导致的系统过载或者资源耗尽。在实际开发中，合理地使用限流机制可以有效保护系统稳定性，避免由于瞬时流量洪峰导致的系统崩溃。 Java自定义注解接口...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值