常见的限流算法

限流的定义

   限流，也称流量控制。是指系统在面临高并发，或者大流量请求的情况下，限制新的请求对系统的访问，从而包管系统的稳定性。限流会导致部分用户请求处理不实时或者被拒，这就影响了用户体验。以是一样平常必要在系统稳定和用户体验之间均衡一下。
    一样平常对于一些调用必要付费的接口，对用户进行限流利用，限制用户的请求次数。
好比：限制单个用户每秒只利用一次
  固定窗口算法

   单元时间内答应部分利用
维护一个计数器，将单元时间段当做一个窗口，计数器记录这个窗口接收请求的次数。
当次数少于限流阀值，就答应访问，并且计数器+1 当次数大于限流阀值，就拒绝访问。
当前的时间窗口已往之后，计数器清零,开始下一个窗口。
  假设单元时间是1秒，限流阀值为3。在单元时间1秒内，每来一个请求,计数器就加1，如果计数器累加的次数超过限流阀值3，后续的请求全部拒绝。等到1s竣事后，计数器清0，重新开始计数
   优点：实现简单
缺点：会出现流量突刺
  

滑动窗口算法

   单元时间内答应部分利用，但这个单元时间是滑动的,必要指定一个滑动单元。
  优点：解决了流量突刺问题
缺点：实现较麻烦，很难找到准确的滑动单元,滑动单元越小，结果越好。
  

漏桶算法（推荐）

   以固定速率处理请求(漏水利用)，当请求桶满了之后，就拒绝请求
  

   优点：在一定水平上可以或许应对流量突刺，以固定速率处理请求，可以或许包管服务器的安全
缺点：无法迅速的对请求做出处理,只能一个个按顺序处理(固定速率处理的缺点)
  令牌桶算法(推荐)

   以固定速率向令牌桶添加令牌，每个令牌代表一定数量的请求，请求必要获取令牌之后才可以或许被处理。没有令牌的请求会被拒绝。

    优点:可以或许并发的处理请求，并发的性能会更高一点。
缺点：照旧存在时间单元选取的问题
  限流粒度

   1.针对某个方法进行限流，单元时间内最多答应XXX个利用利用利用这个方法。
2,针对某个用户进行限流，某个用户单元时间内最多执行XXX个利用
3.针对某个用户X方法，单个用户单元时间内最多执行XXX次这个方法
  当地限流（单机限流）

   这里采用谷歌的Guava RateLimiter实现

1. import com.google.common.util.concurrent.RateLimiter;
3. public static void main(String[] args) {
4.     // 每秒限流5个请求
5.     RateLimiter limiter = RateLimiter.create(5.0);
6.     while (true) {
7.         if (limiter.tryAcquire()) {
8.             // 处理请求
9.         } else {
10.             // 超过流量限制，需要做何处理
11.         }
12.     }
13. }

复制代码

分布式限流（多机限流）

   如果你的项目有多个服务器，好比微服务，那么发起利用分布式限流。
1.把用户的利用频率等数据放到一个集中的存储进行统计；好比Redis，如许无论用户的
请求落到了哪台服务器，都以集中存储中的数据为准。(Redisson --是一个利用 Redis 的工具库)
2.在网关集中进行限流和统计(好比 Sentinel、Spring Cloud Gateway)

1. import org.redisson.Redisson;
2. import org.redisson.api.RSemaphore;
3. import org.redisson.api.RedissonClient;
5. public static void main(String[] args) {
6.     // 创建RedissonClient
7.     RedissonClient redisson = Redisson.create();
9.     // 获取限流器
10.     RSemaphore semaphore = redisson.getSemaphore("mySemaphore");
12.     // 尝试获取许可证
13.     boolean result = semaphore.tryAcquire();
14.     if (result) {
15.         // 处理请求
16.     } else {
17.         // 超过流量限制，需要做何处理
18.     }
19. }

复制代码

分布式限流的实现

   redission配置

1. package com.cheng.config;
4. import org.redisson.config.Config;
5. import lombok.Data;
6. import org.redisson.Redisson;
7. import org.redisson.api.RedissonClient;
8. import org.springframework.boot.context.properties.ConfigurationProperties;
9. import org.springframework.context.annotation.Bean;
10. import org.springframework.context.annotation.Configuration;
12. @Configuration
13. @ConfigurationProperties(prefix = "spring.redis")
14. @Data
15. public class RedissonConfig {
17.     private String host;
19.     private Integer port;
21.     private Integer database;
23.     private String password;
25.     @Bean
26.     public RedissonClient redissonClient() {
27.         Config config = new Config();
28.         config.useSingleServer()
29.         .setAddress("redis://" + host + ":" + port)
30.         .setDatabase(database)
31.         .setPassword(password);
32.         return Redisson.create(config);
33.     }
34. }

复制代码

  RedisLimiterManager服务的实现

1. package com.cheng.manager;
4. import com.cheng.common.ErrorCode;
5. import com.cheng.exception.BusinessException;
6. import org.redisson.api.RRateLimiter;
7. import org.redisson.api.RateIntervalUnit;
8. import org.redisson.api.RateType;
9. import org.redisson.api.RedissonClient;
10. import org.springframework.stereotype.Service;
12. import javax.annotation.Resource;
14. /**
15. * 专门提供 RedisLimiter 限流基础服务
16. */
17. @Service
18. public class RedisLimiterManager {
20.     @Resource
21.     private RedissonClient redissonClient;
23.     /**
24.      * 采用令牌桶限流算法
25.      * 每个用户一个限流器
26.      *
27.      * 限流操作
28.      *
29.      * @param key 区分不同的限流器，比如不同的用户 id 应该分别统计
30.      */
31.     public void doRateLimit(String key) {
33.         // 创建一个名称为user_limiter的限流器，每秒最多访问 2 次
34.         RRateLimiter rateLimiter = redissonClient.getRateLimiter(key);
36.         //RateType.OVERALL 统一速率，全局的
37.         rateLimiter.trySetRate(RateType.OVERALL, 2, 1, RateIntervalUnit.SECONDS);
38.         // 每当一个操作来了后，请求一个令牌
39.         boolean canOp = rateLimiter.tryAcquire(1);
40.         if (!canOp) {
41.             throw new BusinessException(ErrorCode.REQUEST_OVER);
42.         }
43.     }
44. }

复制代码

  测试类

1. package com.cheng.springbootinit.manager;
3. import org.junit.jupiter.api.Test;
4. import org.springframework.boot.test.context.SpringBootTest;
6. import javax.annotation.Resource;
8. import static org.junit.jupiter.api.Assertions.*;
10. @SpringBootTest
11. class RedisLimiterManagerTest {
13.     @Resource
14.     private RedisLimiterManager redisLimiterManager;
16.     @Test
17.     void doRateLimit() throws InterruptedException {
18.         // 模拟一下操作
19.         String userId = "1";
20.         // 瞬间执行2次,每成功一次,就打印'成功'
21.         for (int i = 0; i < 2; i++) {
22.             redisLimiterManager.doRateLimit(userId);
23.             System.out.println("成功");
24.         }
25.         // 睡1秒
26.         Thread.sleep(1000);
27.         // 瞬间执行5次,每成功一次,就打印'成功'
28.         for (int i = 0; i < 5; i++) {
29.             redisLimiterManager.doRateLimit(userId);
30.             System.out.println("成功");
31.         }
32.     }
33. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。