分布式限流,你想知道的都在这里

2021-02-17    分类: 网站建设

前言

在一个高并发系统中对流量的把控是非常重要的,当巨大的流量直接请求到我们的服务器上没多久就可能造成接口不可用,不处理的话甚至会造成整个应用不可用。

比如最近就有个这样的需求,我作为客户端要向kafka生产数据,而kafka的消费者则再源源不断的消费数据,并将消费的数据全部请求到web服务器,虽说做了负载(有4台web服务器)但业务数据的量也是巨大的,每秒钟可能有上万条数据产生。如果生产者直接生产数据的话极有可能把web服务器拖垮。

对此就必须要做限流处理,每秒钟生产一定限额的数据到kafka,这样就能极大程度的保证web的正常运转。

其实不管处理何种场景,本质都是降低流量保证应用的高可用。

常见算法

对于限流常见有两种算法:

  • 漏桶算法
  • 令牌桶算法

漏桶算法比较简单,就是将流量放入桶中,漏桶同时也按照一定的速率流出,如果流量过快的话就会溢出(漏桶并不会提高流出速率)。溢出的流量则直接丢弃。

如下图所示:

分布式限流,你想知道的都在这里

这种做法简单粗暴。

漏桶算法虽说简单,但却不能应对实际场景,比如突然暴增的流量。

这时就需要用到令牌桶算法:

令牌桶会以一个恒定的速率向固定容量大小桶中放入令牌,当有流量来时则取走一个或多个令牌。当桶中没有令牌则将当前请求丢弃或阻塞。

相比之下令牌桶可以应对一定的突发流量。

RateLimiter实现

对于令牌桶的代码实现,可以直接使用Guava包中的RateLimiter。

  1. @Override 
  2. public BaseResponse getUserByFeignBatch(@RequestBody UserReqVO userReqVO) { 
  3.  //调用远程服务 
  4.  OrderNoReqVO vo = new OrderNoReqVO() ; 
  5.  vo.setReqNo(userReqVO.getReqNo()); 
  6.  RateLimiter limiter = RateLimiter.create(2.0) ; 
  7.  //批量调用 
  8.  for (int i = 0 ;i< 10 ; i++){ 
  9.  double acquire = limiter.acquire(); 
  10.  logger.debug("获取令牌成功!,消耗=" + acquire); 
  11.  BaseResponse orderNo = orderServiceClient.getOrderNo(vo); 
  12.  logger.debug("远程返回:"+JSON.toJSONString(orderNo)); 
  13.  } 
  14.  UserRes userRes = new UserRes() ; 
  15.  userRes.setUserId(123); 
  16.  userRes.setUserName("张三"); 
  17.  userRes.setReqNo(userReqVO.getReqNo()); 
  18.  userRes.setCode(StatusEnum.SUCCESS.getCode()); 
  19.  userRes.setMessage("成功"); 
  20.  return userRes ; 

详见此。

调用结果如下:

代码可以看出以每秒向桶中放入两个令牌,请求一次消耗一个令牌。所以每秒钟只能发送两个请求。按照图中的时间来看也确实如此(返回值是获取此令牌所消耗的时间,差不多也是每500ms一个)。

使用RateLimiter有几个值得注意的地方:

允许先消费,后付款,意思就是它可以来一个请求的时候一次性取走几个或者是剩下所有的令牌甚至多取,但是后面的请求就得为上一次请求买单,它需要等待桶中的令牌补齐之后才能继续获取令牌。

总结

针对于单个应用的限流 RateLimiter 够用了,如果是分布式环境可以借助 Redis 来完成。

来做演示。

在 Order 应用提供的接口中采取了限流。首先是配置了限流工具的 Bean:

  1. @Configuration 
  2. public class RedisLimitConfig { 
  3.  @Value("${redis.limit}") 
  4.  private int limit; 
  5.  @Autowired 
  6.  private JedisConnectionFactory jedisConnectionFactory; 
  7.  @Bean 
  8.  public RedisLimit build() { 
  9.  RedisClusterConnection clusterConnection = jedisConnectionFactory.getClusterConnection(); 
  10.  JedisCluster jedisCluster = (JedisCluster) clusterConnection.getNativeConnection(); 
  11.  RedisLimit redisLimit = new RedisLimit.Builder<>(jedisCluster) 
  12.  .limit(limit) 
  13.  .build(); 
  14.  return redisLimit; 
  15.  } 

接着在 Controller 使用组件:

  1. @Autowired 
  2. private RedisLimit redisLimit ; 
  3. @Override 
  4. @CheckReqNo 
  5. public BaseResponse getOrderNo(@RequestBody OrderNoReqVO orderNoReq) { 
  6.  BaseResponse res = new BaseResponse(); 
  7.  //限流 
  8.  boolean limit = redisLimit.limit(); 
  9.  if (!limit){ 
  10.  res.setCode(StatusEnum.REQUEST_LIMIT.getCode()); 
  11.  res.setMessage(StatusEnum.REQUEST_LIMIT.getMessage()); 
  12.  return res ; 
  13.  } 
  14.  res.setReqNo(orderNoReq.getReqNo()); 
  15.  if (null == orderNoReq.getAppId()){ 
  16.  throw new SBCException(StatusEnum.FAIL); 
  17.  } 
  18.  OrderNoResVO orderNoRes = new OrderNoResVO() ; 
  19.  orderNoRes.setOrderId(DateUtil.getLongTime()); 
  20.  res.setCode(StatusEnum.SUCCESS.getCode()); 
  21.  res.setMessage(StatusEnum.SUCCESS.getMessage()); 
  22.  res.setDataBody(orderNoRes); 
  23.  return res ; 

为了方便使用,也提供了注解:

  1. @Override 
  2. @ControllerLimit 
  3. public BaseResponse getOrderNoLimit(@RequestBody OrderNoReqVO orderNoReq) { 
  4.  BaseResponse res = new BaseResponse(); 
  5.  // 业务逻辑 
  6.  return res ; 

该注解拦截了 http 请求,会再请求达到阈值时直接返回。

普通方法也可使用:

  1. @CommonLimit 
  2. public void doSomething(){} 

会在调用达到阈值时抛出异常。

为了模拟并发,在 User 应用中开启了 10 个线程调用 Order(限流次数为5) 接口(也可使用专业的并发测试工具 JMeter 等)。

  1. @Override 
  2. public BaseResponse getUserByFeign(@RequestBody UserReqVO userReq) { 
  3.  //调用远程服务 
  4.  OrderNoReqVO vo = new OrderNoReqVO(); 
  5.  vo.setAppId(1L); 
  6.  vo.setReqNo(userReq.getReqNo()); 
  7.  for (int i = 0; i < 10; i++) { 
  8.  executorService.execute(new Worker(vo, orderServiceClient)); 
  9.  } 
  10.  UserRes userRes = new UserRes(); 
  11.  userRes.setUserId(123); 
  12.  userRes.setUserName("张三"); 
  13.  userRes.setReqNo(userReq.getReqNo()); 
  14.  userRes.setCode(StatusEnum.SUCCESS.getCode()); 
  15.  userRes.setMessage("成功"); 
  16.  return userRes; 
  17. private static class Worker implements Runnable { 
  18.  private OrderNoReqVO vo; 
  19.  private OrderServiceClient orderServiceClient; 
  20.  public Worker(OrderNoReqVO vo, OrderServiceClient orderServiceClient) { 
  21.  this.vo = vo; 
  22.  this.orderServiceClient = orderServiceClient; 
  23.  } 
  24.  @Override 
  25.  public void run() { 
  26.  BaseResponse orderNo = orderServiceClient.getOrderNoCommonLimit(vo); 
  27.  logger.info("远程返回:" + JSON.toJSONString(orderNo)); 
  28.  } 

为了验证分布式效果启动了两个 Order 应用。

效果如下:

实现原理

实现原理其实很简单。既然要达到分布式全局限流的效果,那自然需要一个第三方组件来记录请求的次数。

其中 Redis 就非常适合这样的场景。

  • 每次请求时将当前时间(精确到秒)作为 Key 写入到 Redis 中,超时时间设置为 2 秒,Redis 将该 Key 的值进行自增。
  • 当达到阈值时返回错误。
  • 写入 Redis 的操作用 Lua 脚本来完成,利用 Redis 的单线程机制可以保证每个 Redis 请求的原子性。

Lua 脚本如下:

--lua 下标从 1 开始-- 限流 keylocal key = KEYS[1]-- 限流大小local limit = tonumber(ARGV[1])-- 获取当前流量大小local curentLimit = tonumber(redis.call('get', key) or "0")if curentLimit + 1 > limit then -- 达到限流大小 返回 return 0;else -- 没有达到阈值 value + 1 redis.call("INCRBY", key, 1) redis.call("EXPIRE", key, 2) return curentLimit + 1end

Java 中的调用逻辑:

  1. --lua 下标从 1 开始 
  2. -- 限流 key 
  3. local key = KEYS[1] 
  4. -- 限流大小 
  5. local limit = tonumber(ARGV[1]) 
  6. -- 获取当前流量大小 
  7. local curentLimit = tonumber(redis.call('get', key) or "0") 
  8. if curentLimit + 1 > limit then 
  9.  -- 达到限流大小 返回 
  10.  return 0; 
  11. else 
  12.  -- 没有达到阈值 value + 1 
  13.  redis.call("INCRBY", key, 1) 
  14.  redis.call("EXPIRE", key, 2) 
  15.  return curentLimit + 1 
  16. end 

所以只需要在需要限流的地方调用该方法对返回值进行判断即可达到限流的目的。

当然这只是利用 Redis 做了一个粗暴的计数器,如果想实现类似于上文中的令牌桶算法可以基于 Lua 自行实现。

Builder 构建器

在设计这个组件时想尽量的提供给使用者清晰、可读性、不易出错的 API。

比如第一步,如何构建一个限流对象。

最常用的方式自然就是构造函数,如果有多个域则可以采用重叠构造器的方式:

  1. public A(){} 
  2. public A(int a){} 
  3. public A(int a,int b){} 

缺点也是显而易见的:如果参数过多会导致难以阅读,甚至如果参数类型一致的情况下客户端颠倒了顺序,但不会引起警告从而出现难以预测的结果。

第二种方案可以采用 JavaBean 模式,利用 setter 方法进行构建:

  1. A a = new A(); 
  2. a.setA(a); 
  3. a.setB(b); 

这种方式清晰易读,但却容易让对象处于不一致的状态,使对象处于线程不安全的状态。

所以这里采用了第三种创建对象的方式,构建器:

  1. public class RedisLimit { 
  2.  private JedisCommands jedis; 
  3.  private int limit = 200; 
  4.  private static final int FAIL_CODE = 0; 
  5.  /** 
  6.  * lua script 
  7.  */ 
  8.  private String script; 
  9.  private RedisLimit(Builder builder) { 
  10.  this.limit = builder.limit ; 
  11.  this.jedis = builder.jedis ; 
  12.  buildScript(); 
  13.  } 
  14.  /** 
  15.  * limit traffic 
  16.  * @return if true 
  17.  */ 
  18.  public boolean limit() { 
  19.  String key = String.valueOf(System.currentTimeMillis() / 1000); 
  20.  Object result = null; 
  21.  if (jedis instanceof Jedis) { 
  22.  result = ((Jedis) this.jedis).eval(script, Collections.singletonList(key), Collections.singletonList(String.valueOf(limit))); 
  23.  } else if (jedis instanceof JedisCluster) { 
  24.  result = ((JedisCluster) this.jedis).eval(script, Collections.singletonList(key), Collections.singletonList(String.valueOf(limit))); 
  25.  } else { 
  26.  //throw new RuntimeException("instance is error") ; 
  27.  return false; 
  28.  } 
  29.  if (FAIL_CODE != (Long) result) { 
  30.  return true; 
  31.  } else { 
  32.  return false; 
  33.  } 
  34.  } 
  35.  /** 
  36.  * read lua script 
  37.  */ 
  38.  private void buildScript() { 
  39.  script = ScriptUtil.getScript("limit.lua"); 
  40.  } 
  41.  /** 
  42.  * the builder 
  43.  * @param  
  44.  */ 
  45.  public static class Builder
  46.  private T jedis = null ; 
  47.  private int limit = 200; 
  48.  public Builder(T jedis){ 
  49.  this.jedis = jedis ; 
  50.  } 
  51.  public Builder limit(int limit){ 
  52.  this.limit = limit ; 
  53.  return this; 
  54.  } 
  55. 本文名称:分布式限流,你想知道的都在这里
    转载源于:https://www.cdcxhl.com/news/101365.html

    成都网站建设公司_创新互联,为您提供网页设计公司建站公司营销型网站建设品牌网站制作网站内链网站收录

    广告

    声明:本网站发布的内容(图片、视频和文字)以用户投稿、用户转载内容为主,如果涉及侵权请尽快告知,我们将会在第一时间删除。文章观点不代表本网站立场,如需处理请联系客服。电话:028-86922220;邮箱:631063699@qq.com。内容未经允许不得转载,或转载时需注明来源: 创新互联

    h5响应式网站建设