知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 16 - 如何设计一个分布式限流方案 > 导读:本文用一问一答的方式,从几种限流算法的原理讲到分布式落地与多级限流取舍,读完你能在面试中讲清"为什么推荐令牌桶",并能为自己的接口设计出一套限流方案。适合准备后端面试、以及需要给接口做流量保护的工程师。 ## 一、先建立全局认知 ### Q:限流要解决什么问题? A:结论:限流用来**限制单位时间内允许通过的请求量**,防止恶意刷接口或突发流量打垮系统,超出配额的部分直接拒绝。 典型需求是"API 接口限制每个用户每秒最多 10 次请求": ```text 正常用户:1 秒内请求 3 次 → 全部放行 恶意用户:1 秒内请求 100 次 → 前 10 次放行,后 90 次拒绝(返回 429) ``` 这里的 429 是 HTTP 状态码 "Too Many Requests",表示客户端请求过于频繁。 ### Q:为什么限流要强调"分布式"? A:因为应用通常部署多个实例。单机限流(每台机器各自计数)在集群下无法汇总全局配额:同一个用户的请求被打散到 N 台机器,实际放行量会被放大接近 N 倍。分布式限流需要一个共享的计数器存储(通常用 Redis)来统一裁决。 ### Q:常见的限流算法有哪几种? A:固定窗口计数器、滑动窗口、令牌桶、漏桶,再加上单机场景常用的 Guava RateLimiter。下面逐一拆解它们的原理与代价。 ## 二、理解核心机制 ### Q:固定窗口计数器怎么实现,缺陷在哪? A:每个时间窗口维护一个计数器,窗口内累加,超过阈值就拒绝。 ```text 原理:每个时间窗口(如 1 秒)维护一个计数器 |-------- 1s --------|-------- 1s --------| | 请求: 1,2,...,10 | 请求: 1,2,3 | | 计数: 10(满了) | 计数: 3 | ```  [编辑 Excalidraw 源图](/images/java-interview-copy/business-scenario/16-rate-limiter-fixed-window-counter-diagram.excalidraw) 实现上借助 Redis 的 INCR 加过期时间即可: ```java public boolean isAllowed(String userId) { String key = "rate:" + userId + ":" + (System.currentTimeMillis() / 1000); Long count = redis.opsForValue().increment(key); if (count == 1) { redis.expire(key, 2, TimeUnit.SECONDS); // 设置过期 } return count <= 10; } ``` 关键点:key 里带上时间戳,天然按秒分桶;只在第一次自增(count == 1)时设置过期,避免每次请求都续期导致 key 永不过期。 缺点:窗口边界问题。如果用户在第 1 秒的最后 100ms 发 10 次,第 2 秒的前 100ms 又发 10 次,200ms 内实际发了 20 次。计数器只在各自窗口内判断,跨边界的瞬时流量无法被约束。 ### Q:滑动窗口如何消除边界问题? A:不再按整秒分桶,而是用 Redis ZSet 记录每一次请求的时间戳,每次判断时先移除窗口外的记录,再统计窗口内的数量。 ```text 原理:用 Redis ZSet 记录每次请求的时间戳,统计窗口内的请求数 ZADD rate:{userId} {timestamp} {uniqueId} ZREMRANGEBYSCORE rate:{userId} 0 {timestamp - window} ZCARD rate:{userId} ```  这些命令必须作为整体执行,否则会有并发竞争,因此用 Lua 脚本保证原子性: ```lua -- sliding_window.lua local key = KEYS[1] local window = tonumber(ARGV[1]) -- 窗口大小(毫秒) local limit = tonumber(ARGV[2]) -- 限制次数 local now = tonumber(ARGV[3]) -- 当前时间戳 -- 移除窗口外的记录 redis.call('ZREMRANGEBYSCORE', key, 0, now - window) -- 统计窗口内的请求数 local count = redis.call('ZCARD', key) if count < limit then -- 未超限,记录本次请求 redis.call('ZADD', key, now, now .. math.random()) redis.call('EXPIRE', key, math.ceil(window / 1000) + 1) return 1 -- 放行 end return 0 -- 拒绝 ``` 关键点:ZREMRANGEBYSCORE 清理过期记录,ZCARD 得到真实窗口内的数量,两个动作在同一个原子脚本内完成,避免"统计和写入之间被插队"。用 `now .. math.random()` 作为 ZSet 成员,是为了避免同一毫秒的多次请求因成员重复而互相覆盖。 优点:精确,没有窗口边界问题。缺点:每个请求都要存一条记录,内存占用大。 ### Q:令牌桶为什么是被推荐的方案? A:令牌桶以固定速率往桶里放令牌,桶有容量上限;请求来了取一个令牌,桶空了就拒绝。它既能约束平均速率,又允许一定程度的突发流量(桶里攒下的令牌可以一次用完)。  *图:令牌生成器与令牌桶:请求来了取一个令牌* ```text 原理:以固定速率往桶里放令牌,请求来了取一个令牌,桶空了就拒绝 ┌─────────┐ │ 令牌生成器 │ ← 每 100ms 放 1 个令牌 └────┬────┘ ↓ ┌─────────┐ │ 令牌桶 │ ← 最多存 10 个令牌(桶容量) │ ●●●●●● │ └────┬────┘ ↓ 请求来了 → 取一个令牌 → 有令牌就放行,没有就拒绝 特点:允许突发流量(桶里攒了令牌可以一次用完) ```  Lua 实现的核心是"惰性补令牌"——不真的启动定时器,而是按当前时间与上次时间的差值算出这段时间应新增的令牌数: ```lua -- token_bucket.lua local key = KEYS[1] local capacity = tonumber(ARGV[1]) -- 桶容量 local rate = tonumber(ARGV[2]) -- 每秒生成令牌数 local now = tonumber(ARGV[3]) -- 当前时间(秒) local requested = tonumber(ARGV[4]) -- 请求的令牌数 -- 获取上次的令牌数和时间 local last_tokens = tonumber(redis.call('HGET', key, 'tokens') or capacity) local last_time = tonumber(redis.call('HGET', key, 'timestamp') or now) -- 计算这段时间新生成的令牌 local elapsed = math.max(0, now - last_time) local new_tokens = math.min(capacity, last_tokens + elapsed * rate) -- 判断令牌是否足够 if new_tokens >= requested then new_tokens = new_tokens - requested redis.call('HSET', key, 'tokens', new_tokens) redis.call('HSET', key, 'timestamp', now) redis.call('EXPIRE', key, math.ceil(capacity / rate) + 1) return 1 -- 放行 end redis.call('HSET', key, 'tokens', new_tokens) redis.call('HSET', key, 'timestamp', now) return 0 -- 拒绝 ``` 关键点:`math.min(capacity, ...)` 保证令牌数不会超过桶容量;首次访问时把 HGET 的缺省值取为 capacity,相当于初始桶是满的;被拒绝时同样要把 tokens 和 timestamp 写回,这样下一轮计算的基准时间才是最新的。适用场景:需要约束平均速率、同时容忍一定突发的接口,这也是 Guava RateLimiter、Sentinel 等框架采用的模型。 [编辑 Excalidraw 源图](/images/java-interview-copy/business-scenario/16-rate-limiter-rate-limiter-token-bucket-diagram.excalidraw) ### Q:漏桶和令牌桶有什么区别,什么时候用漏桶? A:两者方向不同——令牌桶约束"进得多快",漏桶约束"出得多稳"。 ```text 原理:请求先进入容量有限的队列,再以固定速率从队列中流出;队列满时直接拒绝新请求。 特点:输出速率稳定,能平滑突发流量;但与令牌桶不同,突发请求不能立即全部被处理。 ```  适用场景:需要保护下游服务、严格平滑流量的场景。代价是高峰请求可能排队等待,桶满时会返回 429。 ## 三、放进真实场景 ### Q:单机限流在真实项目里怎么用? A:直接用 Guava 的 RateLimiter,无需依赖 Redis。 ```java // 每秒 10 个令牌 RateLimiter limiter = RateLimiter.create(10); public void handleRequest() { if (limiter.tryAcquire()) { // 放行 processRequest(); } else { // 拒绝 throw new RateLimitException("请求过于频繁"); } } ``` 关键点:RateLimiter 内部就是令牌桶模型,tryAcquire 以非阻塞方式尝试取令牌,取到则放行,取不到立即拒绝。优点:简单,不依赖 Redis。缺点:只能单机限流,集群环境下每台机器独立计数。 ### Q:实际系统里怎么把这些方案组合起来? A:先按精度、突发支持、是否分布式、实现复杂度做选择,再叠加多级限流。 | 方案 | 精确度 | 突发流量 | 分布式 | 实现复杂度 | |------|--------|---------|--------|-----------| | 固定窗口 | 低(边界问题) | 不支持 | 支持 | 极低 | | 滑动窗口 | 高 | 不支持 | 支持 | 中 | | 令牌桶 | 高 | 支持 | 支持 | 中 | | Guava RateLimiter | 高 | 支持 | 不支持 | 极低 | 设计取舍:固定窗口实现最简单、精度最差;滑动窗口精度高但内存开销大;令牌桶兼顾精度与突发;漏桶则牺牲吞吐换取下游稳定。单一算法很难覆盖所有层级,工程上常见的做法是多级限流——网关层做全局粗粒度限流,应用层做实例级保护,接口层做业务维度的精细限流。限流触发后的下游体验也要设计好,通常返回 429 并提示"请求过于频繁"。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:按四步答。 1. 先说四种算法:固定窗口、滑动窗口、漏桶、令牌桶 2. 推荐令牌桶(允许突发流量,Guava 和 Sentinel 都用这个) 3. 分布式限流用 Redis + Lua 脚本保证原子性 4. 加分项:提到多级限流(网关层 + 应用层 + 接口层),以及 Sentinel 框架 ### Q:为什么强调用 Lua 脚本,而不是多条 Redis 命令? A:因为"读计数 → 判断 → 写计数"是典型的复合操作,拆成多条命令时请求会交叉执行,导致超发。Redis 执行 Lua 脚本是单线程原子的,能把整条判断链路封装成一次原子操作。这正是令牌桶、滑动窗口都选择 Lua 实现的根本原因。 --- ## 自测 1. 固定窗口的"边界问题"具体指什么?滑动窗口为什么能解决它? 2. 令牌桶的桶容量和令牌生成速率分别控制什么? 3. 集群部署时,为什么 Guava RateLimiter 的限流会失效?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入