Redis:限流算法

一、限流算法分类

• 简单限流算法
• 漏斗限流算法(令牌桶算法)
• 分布式漏斗限流算法(分布式令牌桶算法)

二、简单限流算法

1. 问题引入

系统要限定用户的某个行为在指定的时间里只能允许发生 N 次，如何使用 Redis 的数据结构来实现这个限流的功能？

2. 解决方案

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

3. 代码实现

# coding: utf8
import time
import redis

client = redis.StrictRedis()
def is_action_allowed(user_id, action_key, period, max_count):
	key = 'hist:%s:%s' % (user_id, action_key)
	now_ts = int(time.time() * 1000) # 毫秒时间戳
	with client.pipeline() as pipe: # client 是 StrictRedis 实例
		# 记录行为
		pipe.zadd(key, now_ts, now_ts) # value 和 score 都使用毫秒时间戳
		# 移除时间窗口之前的行为记录，剩下的都是时间窗口内的
		pipe.zremrangebyscore(key, 0, now_ts - period * 1000)
		# 获取窗口内的行为数量
		pipe.zcard(key)
		# 设置 zset 过期时间，避免冷用户持续占用内存
		# 过期时间应该等于时间窗口的长度，再多宽限 1s
		pipe.expire(key, period + 1)
		# 批量执行
		_, _, current_count, _ = pipe.execute()
	# 比较数量是否超标
	return current_count <= max_count

for i in range(20):
	print is_action_allowed("laoqian", "reply", 60, 5)

4. 算法优缺点

• 优点:简单
• 缺点:如果量很大，比如限定 60s 内操作不得超过 100w 次这样的参数，它是不适合做这样的限流的，因为会消耗大量的存储空间。

三、漏斗限流算法(令牌桶算法)

1. 算法思想

在每次灌水前都会被调用以触发漏水，给漏斗腾出空间来。能腾出多少空间取决于过去了多久以及流水的速率。

2. 单机漏斗算法

# coding: utf8
import time

class Funnel:
    def __init__(self, capacity, leaking_rate):
        self.capacity = capacity    # 漏斗容量
        self.leaking_rate = leaking_rate    # 流出速率
        self.left_quota = capacity    # 漏斗剩余空间
        self.leaking_ts = time.time()    # 上一次漏水时间

    def make_space(self):
        now_ts = time.time()
        delta_ts = now_ts - self.leaking_ts    # 距离上一次漏水过去了多久
        delta_quota = delta_ts * self.leaking_rate    # 腾出的空间
        if delta_quota < 1:    # 腾的空间过小等待下一次
            return 
        self.left_quota += delta_quota    # 增加剩余空间
        self.leaking_ts = now_ts    # 记录漏水时间
        if self.left_quota > self.capacity:    # 剩余空间不得高于容量
            self.left_quota = self.capacity
        
    def watering(self, quota):
        self.make_space()
        if self.left_quota >= quota:    # 判断剩余空间是否足够
            self.left_quota -= quota
            return True
        return False


funnels = {}    # 所有的漏斗

def is_action_allowed(
    user_id, action_key, capacity, leaking_rate):
    key = '{}:{}'.format(user_id, action_key)
    funnel = funnels.get(key)
    if not funnel:
        funnels[key] = Funnel(capacity, leaking_rate)
    return funnel.watering(1)


for i in range(20):
    print is_action_allowed('tom', 'reply', 15, 0.5)

Funnel 对象的 make_space 方法是漏斗算法的核心，其在每次灌水前都会被调用以触发漏水，给漏斗腾出空间来。能腾出多少空间取决于过去了多久以及流水的速率。Funnel 对象占据的空间大小不再和行为的频率成正比，它的空间占用是一个常量。

四、分布式漏斗限流算法(分布式令牌桶算法)

1. 问题引入

问题来了，分布式的漏斗算法该如何实现？能不能使用 Redis 的基础数据结构来搞定？我们观察 Funnel 对象的几个字段，我们发现可以将 Funnel 对象的内容按字段存储到一个 hash 结构中，灌水的时候将 hash 结构的字段取出来进行逻辑运算后，再将新值回填到hash 结构中就完成了一次行为频度的检测。
但是有个问题，我们无法保证整个过程的原子性。从 hash 结构中取值，然后在内存里运算，再回填到 hash 结构，这三个过程无法原子化，意味着需要进行适当的加锁控制。而一旦加锁，就意味着会有加锁失败，加锁失败就需要选择重试或者放弃。
如果重试的话，就会导致性能下降。如果放弃的话，就会影响用户体验。同时，代码的复杂度也跟着升高很多。这真是个艰难的选择，我们该如何解决这个问题呢？

2. Redis-Cell介绍

Redis 4.0 提供了一个限流 Redis 模块，它叫 redis-cell。该模块也使用了漏斗算法，并提供了原子的限流指令。有了这个模块，限流问题就非常简单了。
官网地址

3. Redis-Cell使用

请参考:Redis-Cell使用

//返回值说明
> cl.throttle laoqian:reply 15 30 60
1) (integer) 0 # 0 表示允许，1 表示拒绝
2) (integer) 16 # 漏斗容量 capacity
3) (integer) 15 # 漏斗剩余空间 left_quota
4) (integer) -1 # 如果拒绝了，需要多长时间后再试(漏斗有空间了，单位秒)
5) (integer) 2 # 多长时间后，漏斗完全空出来(left_quota==capacity，单位秒)

//在执行限流指令时，如果被拒绝了，就需要丢弃或重试。
//cl.throttle 指令考虑的非常周到，连重试时间都帮你算好了，直接取返回结果数组的第四个值进行 sleep 即可，如果不想阻塞线程，也可以异步定时任务来重试。