Redis 的 简单限流（滑动窗口）

此文档源自钱文品老师所著《Redis 深度历险：核心原理和应用实践》

限流算法在分布式领域是一个经常被提起的话题，当系统的处理能力有限时，如何阻止计划外的请求继续对系统施压，这是一个需要重视的问题。

除了控制流量，限流还有一个应用目的是用于控制用户行为，避免垃圾请求。比如在UGC 社区，用户的发帖、回复、点赞等行为都要严格受控，一般要严格限定某行为在规定时间内允许的次数，超过了次数那就是非法行为。对非法行为，业务必须规定适当的惩处策略。

如何使用 Redis 来实现简单限流策略？

首先我们来看一个常见 的简单的限流策略。系统要限定用户的某个行为在指定的时间里只能允许发生 N 次，如何使用 Redis 的数据结构来实现这个限流的功能？
我们先定义这个接口，理解了这个接口的定义。

# 指定用户 user_id 的某个行为 action_key 在特定的时间内 period 只允许发生一定的次数
max_count
def is_action_allowed(user_id, action_key, period, max_count):
 return True
# 调用这个接口 , 一分钟内只允许最多回复 5 个帖子
can_reply = is_action_allowed("laoqian", "reply", 60, 5)
if can_reply:
 do_reply()
else:
 raise ActionThresholdOverflow()

解决方案

这个限流需求中存在一个滑动时间窗口， zset 数据结构的 score 值，可以通过 score 来圈出这个时间窗口来。而且我们只需要保留这个时间窗口，窗口之外的数据都可以砍掉。那这个 zset 的 value 填什么比较合适呢？它只需要保证唯一性即可，用 uuid 会比较浪费空间，那就改用毫秒时间戳吧。

如图所示，用一个 zset 结构记录用户的行为历史，每一个行为都会作为 zset 中的一个key 保存下来。同一个用户同一种行为用一个 zset 记录。

为节省内存，我们只需要保留时间窗口内的行为记录，同时如果用户是冷用户，滑动时间窗口内的行为是空记录，那么这个 zset 就可以从内存中移除，不再占用空间。

通过统计滑动窗口内的行为数量与阈值 max_count 进行比较就可以得出当前的行为是否允许。用代码表示如下：

public class SimpleRateLimiter {

    private final Jedis jedis;

    public SimpleRateLimiter(Jedis jedis) {
        this.jedis = jedis;
    }

    public boolean isActionAllow(String userId,String actionKey,int period,int maxCount) throws IOException {
        String key=String.format("hist6:%s:%s",userId,actionKey);
        long nowTs=System.currentTimeMillis();
        //毫秒时间戳
        Pipeline pipeline=jedis.pipelined();
        pipeline.multi();//用了multi，也就是事务，能保证一系列指令的原子顺序执行
        //value和score都使用毫秒时间戳
        pipeline.zadd(key,nowTs,nowTs+"");
        //移除时间窗口之前的行为记录，剩下的都是时间窗口内的
        pipeline.zremrangeByScore(key,0,nowTs-period*1000);
        //获得[nowTs-period*1000,nowTs]的key数量
        Response<Long> count=pipeline.zcard(key);
        //每次设置都能保持更新key的过期时间
        pipeline.expire(key,period);
        pipeline.exec();
        pipeline.close();
        return count.get()<=maxCount;
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        Jedis jedis=new Jedis("localhost",6379);
        jedis.auth("iostream");
        SimpleRateLimiter limiter=new SimpleRateLimiter(jedis);
        for (int i = 0; i < 20; i++) {
            //每个用户在1秒内最多能做五次动作
            System.out.println(limiter.isActionAllow("viscu","reply",1,5));
        }
    }
}

每一个行为到来时，都维护一次时间窗口。将时间窗口外的记录全部清理掉，只保留窗口内的记录zset 集合中只有 score 值非常重要，value 值没有特别的意义，只需要保证它是唯一的就可以了。

因为这几个连续的 Redis 操作都是针对同一个 key 的，使用 pipeline 可以显著提升Redis 存取效率。但这种方案也有缺点，因为它要记录时间窗口内所有的行为记录，如果这个量很大，比如限定 60s 内操作不得超过 100w 次这样的参数，它是不适合做这样的限流的，因为会消耗大量的存储空间。

看看在项目中用的一个简单限流（看看就好）

自定义注解

@Target(METHOD)
@Retention(RUNTIME)
public @interface AccessLimit {
    //时间
    int seconds();
    //次数
    int maxCount() default 5;
    //是否需要登录
    boolean needLogin() default false;
}

拦截器

@Configuration
public class InterceptorConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 多个拦截器组成一个拦截器链
        // addPathPatterns 用于添加拦截规则
        // excludePathPatterns 用户排除拦截
        registry.addInterceptor(accessInterceptor()).addPathPatterns("/limit/**");
        super.addInterceptors(registry);
    }

    @Bean
    public AccessInterceptor accessInterceptor(){
        return new AccessInterceptor();
    }
}

逻辑处理

public class AccessInterceptor extends HandlerInterceptorAdapter {

    @Autowired
    RedisService redisService;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        //获取方法上的注解
        HandlerMethod hm = (HandlerMethod) handler;
        AccessLimit accessLimit = hm.getMethodAnnotation(AccessLimit.class);

        //获取配置参数
        int seconds = accessLimit.seconds();
        int maxCount = accessLimit.maxCount();
        boolean needLogin = accessLimit.needLogin();

        String key = request.getRequestURI();

        //判断用户是否登录
        //todo cookie / token 两种实现
        //getUser(request, response);

        AccessKey ak = AccessKey.withExpire(seconds);
        Integer count = redisService.get(ak, key, Integer.class);

        if (count == null) {
            redisService.set(ak, key, 1);
        } else if (count < maxCount) {
            redisService.incr(ak, key);
        } else {
            render(response, "休息下吧老哥");
            System.out.println("休息下吧老哥");
            return false;
        }

        return super.preHandle(request, response, handler);
    }

    private void render(HttpServletResponse response, String cm) throws Exception {
        response.setContentType("application/json;charset=UTF-8");
        OutputStream out = response.getOutputStream();
        String str = JSON.toJSONString(cm);
        out.write(str.getBytes("UTF-8"));
        out.flush();
        out.close();

    }
}