接口限流

Myth丶恋晨 2023-01-19 03:18 169阅读 0赞

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

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

本文主要介绍应用级限流方法，分布式限流、流量入口限流（接入层如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()方法尝试获取许可证，信号量的本质是控制某个资源可被同时访问的个数，在一定程度上可以控制某资源的访问频率，但不能精确控制，控制访问频率的模式见下文描述。

## 二、控制访问速率 ##

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

### 漏桶算法 ###

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

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

### 令牌桶算法 ###

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

*  每过1/r秒桶中增加一个令牌。
 *  桶中最多存放b个令牌，如果桶满了，新放入的令牌会被丢弃。
 *  当一个n字节的数据包到达时，消耗n个令牌，然后发送该数据包。
 *  如果桶中可用令牌小于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参数实现一开始就是平滑固定速率。

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

# 分布式限流 #

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

自定义注解：

/**
     * @author yzd
     * @Description: 限流
     * @create 2021-05-07 13:46
     **/
    @Inherited
    @Documented
    @Target({
        ElementType.FIELD, ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface AccessLimit {
        
    
        /**
         * 限定次数
         *
         * @return
         */
        int limit() default 5;
    
        /**
         * 时间段内
         *
         * @return
         */
        int sec() default 5;
    }

拦截器：

/**
     * @author yzd
     * @Description: 限流 拦截器
     * @create 2021-05-07 13:47
     **/
    @Component
    public class AccessLimitInterceptor implements HandlerInterceptor {
        
    
        @Autowired
        private RedisTemplate redisTemplate;
    
        @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 = IpUtils.getIpAddr(request) + request.getRequestURI();
                Integer maxLimit = (Integer) redisTemplate.opsForValue().get(key);
                if (maxLimit == null) {
        
                    //set时一定要加过期时间
                    redisTemplate.opsForValue().set(key, 1, sec, TimeUnit.SECONDS);
                } else if (maxLimit < limit) {
        
                    redisTemplate.opsForValue().set(key, maxLimit + 1, sec, TimeUnit.SECONDS);
                } else {
        
                    output(response, JSONUtil.toJsonStr(JsonResult.fail("请求频繁,稍后再试!")));
                    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) {
        
    
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        
    
        }
    }

注入拦截器：

/**
     * @author yzd
     * @Description: 注入自定义拦截器
     * @create 2021-05-07 14:03
     **/
    @Configuration
    public class WebConfig implements WebMvcConfigurer {
        
    
        @Autowired
        private AccessLimitInterceptor accessLimitInterceptor;
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
        
            registry.addInterceptor(accessLimitInterceptor);
        }
    }

注入redis：

@Slf4j
    @Configuration
    public class RedisTemplateConfiguration {
        
    
        @Bean(name = "redisTemplate")
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            redisTemplate.setKeySerializer(keySerializer());
            redisTemplate.setHashKeySerializer(keySerializer());
            redisTemplate.setValueSerializer(valueSerializer());
            redisTemplate.setHashValueSerializer(valueSerializer());
            log.info("自定义 RedisTemplate 加载完成");
            return redisTemplate;
        }
    
        private RedisSerializer<String> keySerializer() {
        
            return new StringRedisSerializer();
        }
    
        private RedisSerializer<Object> valueSerializer() {
        
            return new GenericJackson2JsonRedisSerializer();
        }
    
    }

ip工具类：

import javax.servlet.http.HttpServletRequest;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.LineNumberReader;
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    
    /**
     @Description: ip地址获取工具
     @author yzd
     @create 2021-04-14 10:59
     **/
    public class IpUtils {
        
    
        public static final String UN_KNOWN = "unknown";
        public static final String LOCAL = "127.0.0.1";
        public static final String LOCAL_STR = "0:0:0:0:0:0:0:1";
    
        /**
         * 获取当前网络ip
         * @param request
         * @return
         */
        public static String getIpAddr(HttpServletRequest request){
        
            String ipAddress = request.getHeader("x-forwarded-for");
            if (ipAddress == null || ipAddress.length() == 0 || UN_KNOWN.equalsIgnoreCase(ipAddress)) {
        
                ipAddress = request.getHeader("Proxy-Client-IP");
            }
            if (ipAddress == null || ipAddress.length() == 0 || UN_KNOWN.equalsIgnoreCase(ipAddress)) {
        
                ipAddress = request.getHeader("WL-Proxy-Client-IP");
            }
            if (ipAddress == null || ipAddress.length() == 0 || UN_KNOWN.equalsIgnoreCase(ipAddress)) {
        
                ipAddress = request.getRemoteAddr();
                if (LOCAL.equals(ipAddress) || LOCAL_STR.equals(ipAddress)) {
        
                    //根据网卡取本机配置的IP
                    InetAddress inet=null;
                    try {
        
                        inet = InetAddress.getLocalHost();
                    } catch (UnknownHostException e) {
        
                        e.printStackTrace();
                    }
                    ipAddress= inet.getHostAddress();
                }
            }
            //对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
            int i = 15;
            if (ipAddress != null && ipAddress.length() > i) {
        
                String str = ",";
                if (ipAddress.indexOf(str) > 0) {
        
                    ipAddress = ipAddress.substring(0,ipAddress.indexOf(","));
                }
            }
            return ipAddress;
        }
    
        /**
         * 获得MAC地址
         * @param ip
         * @return
         */
        public static String getMacAddress(String ip){
        
            String str = "";
            String macAddress = "";
            try {
        
                Process p = Runtime.getRuntime().exec("nbtstat -A " + ip);
                InputStreamReader ir = new InputStreamReader(p.getInputStream());
                LineNumberReader input = new LineNumberReader(ir);
                int j = 100;
                for (int i = 1; i < j; i++) {
        
                    str = input.readLine();
                    if (str != null) {
        
                        if (str.indexOf("MAC Address") > 1) {
        
                            macAddress = str.substring(str.indexOf("MAC Address") + 14, str.length());
                            break;
                        }
                    }
                }
            } catch (IOException e) {
        
                e.printStackTrace(System.out);
            }
            return macAddress;
        }
    }

使用：

@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 !";
        }
    }

# 接入层限流 #

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

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

**用limit\_req模块来限制基于IP请求的访问频率：**  
[http://nginx.org/en/docs/http/ngx\_http\_limit\_req\_module.html][http_nginx.org_en_docs_http_ngx_http_limit_req_module.html]  
**也可以用tengine中的增强版：**  
[http://tengine.taobao.org/document\_cn/http\_limit\_req\_cn.html][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;

1.  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;
            }

[79340da5c8e9e723bca9c00bd7eb1aa7.png]: /images/20221021/3d9a8a9ebccb40fa8f473958a99faacc.png
[a2ee9e232bd64d14bfcd1b372c4ac67c.png]: /images/20221021/ea6fddc1c3814359aa41a05ecdc6b8f7.png
[20180614150045360]: /images/20221021/4f98ef08a41c4912b996c29db2753442.png
[http_nginx.org_en_docs_http_ngx_http_limit_req_module.html]: http://nginx.org/en/docs/http/ngx_http_limit_req_module.html
[http_tengine.taobao.org_document_cn_http_limit_req_cn.html]: http://tengine.taobao.org/document_cn/http_limit_req_cn.html