高并发服务限流实践（一）

本文从限流背景开始，介绍了限流的常用方法、代码实现和限流组件源码分析。本文是该系列的第一篇，介绍限流背景，限流算法和ratelimiter限流实现。第二篇会介绍ratelimiter的源码实现。

一、限流背景

限流是保护系统的重要利器，通过对并发访问或请求数进行限制或者对一个时间窗口内的请求数进行限速，用于防止大流量或突发流量导致服务崩溃。一旦达到限制速率则可以拒绝服务或进行流量整形。

在实践中会在网络层，接入层（nginx），应用层进行限流。本文介绍的是应用层的限流方式，对于其它层原理类似，分层或使用的技术手段不同而已。

一般的大流量场景如秒杀，抢购系统，大并发电商系统等，实现技术可以限制线程池，数据库连接池，瞬间并发数，接口调用速率、限制mq消费速率。根据网络连接数、网络流量、cpu或内存负载等来限流等。

二、限流算法

限流常用的基本算法有两种，漏桶算法和令牌桶算法。

如上图就像一个漏斗一样，进来的水量就像访问流量一样，出去的水量像系统处理请求一样。当访问流量过大时，漏斗中就会积水，如果水太多了就会溢出。

2.1 漏桶算法

漏桶算法一般有队列（queue）和处理器两个组件构成，队列用于存放请求，处理器复杂处理请求。

（1）请求达到如果未满，则放入队列，之后有处理器按照固定速率取出请求进行处理。

（2）如果请求量过大超出了最大限制，则新来的请求会被抛弃。

漏桶算法示意图

2.2 令牌桶算法

令牌桶算法与漏桶算法组件构成结构类似，区别在于令牌桶会先发放令牌，如果有令牌，则继续处理，无则抛弃请求。

（1）往桶内按照固定速率，添加固定容量的令牌。令牌数量达到最大限制，则会丢弃或拒绝。

（2）当请求到达时，如果获取到令牌则直接处理，如果获取不到，则会丢弃或放到缓存区。

令牌桶算法示意图

2.3令牌桶算法和漏桶算法对比

（1）令牌桶算法是按照固定速率往桶中添加令牌，请求是否被处理需要看桶中令牌是否足够，当令牌数减为零时则拒绝新的请求；漏桶则是按照常量固定速率流出请求，流入请求速率任意，当流入的请求数累积到漏桶容量时，则新流入的请求被拒绝；

（2）令牌桶算法限制的是平均流入速率，允许突发请求，只要有令牌就可以处理，支持一次拿多个令牌，比如10个或15个；漏桶算法限制的是常量流出速率，即流出速率是一个固定常量，比如速率流出1，则一直都是1，而不能一次是1，下次是2，从而可以平滑突发流入速率；

（3）令牌桶算法允许一定程度的突发流量，而漏桶算法可以平滑流出速率；

三、限流实现

 guava的ratelimiter提供了令牌桶算法实现：平滑突发限流(smoothbursty)和平滑预热限流(smoothwarmingup)实现。我们将通过案例介绍ratelimiter的使用。

3.1 maven引用

1 <dependency>
2 <groupid>com.google.guava</groupid>
3 <artifactid>guava</artifactid>
4 <version>28.1-jre</version>
5 </dependency>

3.2 定义注解

 1 @target({elementtype.parameter, elementtype.method})
 2 @retention(retentionpolicy.runtime)
 3 @documented
 4 public @interface requestratelimitannotation {
 5 /**
 6 * 固定令牌个数
 7 * @return
 8 */
 9 double limitnum();
10 /**
11 * 获取令牌超时时间
12 * @return
13 */
14 long timeout();
15 /**
16 * 单位-默认毫秒
17 * @return
18 */
19 timeunit timeunit() default timeunit.milliseconds;
20 /**
21 * 无法获取令牌时的错误信息
22 * @return
23 */
24 string errmsg() default "请求太频繁！";
25 }

3.3 aop拦截

 1 @slf4j
 2 @aspect
 3 @component
 4 public class requestratelimitaspect { 8     
 9     /**
10      * 使用url做为key,存放令牌桶 防止每次重新创建令牌桶
11      */
12     private map<string, ratelimiter> limitmap = maps.newconcurrentmap();
13 
14     @pointcut("@annotation(com.itfly8.test.annotation.requestratelimitannotation)")
15     public void execmethod() {
16 
17     }
18 
19     @around("execmethod()")
20     public object doaround(proceedingjoinpoint joinpoint) throws throwable {    
21         //获取请求uri
22         httpservletrequest request = ((servletrequestattributes) requestcontextholder.getrequestattributes()).getrequest();
23         string requrl=request.getrequesturi();
24         
25         // 获取令牌
26         requestratelimitannotation ratelimiter = this.getrequestratelimiter(joinpoint);
27         if (objects.nonnull(ratelimiter)) {
28             ratelimiter limiter = getratelimiter(requrl, ratelimiter);
29             boolean acquire = limiter.tryacquire(ratelimiter.timeout(), ratelimiter.timeunit());
30             if (!acquire) {
31                 return new response<>("200", requrl.concat(ratelimiter.errmsg()));
32             }
33         }
34 
35         //获得令牌，继续执行
36         return joinpoint.proceed();
37     }
38     
39 
40     /**
41      * 获取ratelimiter
42      * 
43      * @return
44      */
45     private ratelimiter getratelimiter(string requrl, requestratelimitannotation ratelimiter) {
46         ratelimiter limiter = limitmap.get(requrl);
47         if (objects.isnull(limiter)) {
48             synchronized (this) {
49                 limiter = limitmap.get(requrl);
50                 if (objects.isnull(limiter)) {
51                     limiter = ratelimiter.create(ratelimiter.limitnum());
52                     limitmap.put(requrl, limiter);
53                     log.info("requestratelimitaspect请求{},创建令牌桶,容量{} 成功!!!", requrl, ratelimiter.limitnum());
54                 }
55             }
56         }
57         
58         return limiter;
59     }
60 
61     /**
62      * 获取注解对象
63      * @param joinpoint 对象
64      * @return ten logannotation
65      */
66     private requestratelimitannotation getrequestratelimiter(final joinpoint joinpoint) {
67         method[] methods = joinpoint.gettarget().getclass().getdeclaredmethods();
68         string name = joinpoint.getsignature().getname();
69         if (!stringutils.isempty(name)) {
70             for (method method : methods) {
71                 requestratelimitannotation annotation = method.getannotation(requestratelimitannotation.class);
72                 if (!objects.isnull(annotation) && name.equals(method.getname())) {
73                     return annotation;
74                 }
75             }
76         }
77         return null;
78     }
79 }

3.4 controller应用

 1 @restcontroller
 2 @requestmapping("/test/")
 3 public class examplecontroller {
 4 @requestratelimitannotation(limitnum = 2,timeout = 10)
 5 @postmapping("/ratelimit")
 6 public string testratelimit() {
 7      /**
 8      * 测试代码
 9      */
10     return "success";
11 }

3.5 执行效果

如果超过最大限流，则打印日志如下：

1 com.itlfy8.test.controller.testcontroller result:{"code":"200","msg":"/test/ratelimit请求太频繁！","data":{}}

四、总结

本文从限流场景、限流算法和ratelimit的使用三个方面，介绍了高并发限流的方法，代码提供了一种较为通用的实现方式，在此基础上扩展可以实现比较通用的限流机制。