常见限流算法：令牌桶、漏桶、计数器、滑动窗口的原理与对比

限流算法的核心目标是在高并发场景下控制请求速率，防止系统过载。Go 语言在构建高吞吐微服务时，选择合适的限流算法直接决定了尾延迟的稳定性。本节将深入剖析四种经典限流算法的原理、实现要点与适用场景。

1. 计数器算法（固定窗口）

计数器算法是最直观的限流实现：将时间划分为固定大小的窗口（如 1 秒），每个窗口内维护一个计数器，请求到达时计数器加 1，若超过阈值则拒绝。

// 计数器限流核心逻辑（伪代码）
type CounterLimiter struct {
    threshold int64
    window    time.Duration
    count     atomic.Int64
    lastReset time.Time
}

func (l *CounterLimiter) Allow() bool {
    now := time.Now()
    if now.Sub(l.lastReset) >= l.window {
        l.count.Store(0)
        l.lastReset = now
    }
    return l.count.Add(1) <= l.threshold
}

2. 滑动窗口算法

滑动窗口将固定窗口细分为多个小格子（如 1s 窗口拆成 10 个 100ms 格子），每个格子独立计数。窗口滑动时，丢弃过期格子并累加当前窗口内所有格子的计数，从而平滑流量突变。

// 滑动窗口核心结构（Go 实现片段）
type SlidingWindow struct {
    size    int           // 格子数
    buckets []int64       // 每个格子的计数
    span    time.Duration // 每个格子的时间跨度
    head    int           // 当前窗口起始格子索引
    total   int64         // 当前窗口总计数
    mu      sync.Mutex
}

3. 漏桶算法

漏桶算法将请求视为水滴，以恒定速率从桶底漏出（处理），桶满则溢出（拒绝）。它强制输出速率完全平滑，适合需要严格削峰填谷的场景。

• 桶容量（burst）：允许的瞬时最大积压请求数。
• 漏出速率（rate）：恒定处理速率，单位请求/秒。
• 行为特征：无论输入多不均匀，输出始终平滑如流水。

// 虚拟漏桶实现（基于时间戳计算）
type LeakyBucket struct {
    rate   float64 // 漏出速率（请求/秒）
    cap    int64   // 桶容量
    water  float64 // 当前水量
    lastTs time.Time
    mu     sync.Mutex
}

func (b *LeakyBucket) Allow() bool {
    b.mu.Lock()
    defer b.mu.Unlock()
    now := time.Now()
    elapsed := now.Sub(b.lastTs).Seconds()
    b.water = math.Max(0, b.water - elapsed * b.rate) // 先漏水
    b.lastTs = now
    if b.water < float64(b.cap) {
        b.water++
        return true
    }
    return false
}

4. 令牌桶算法

令牌桶以固定速率向桶中添加令牌，请求到达时需获取一个令牌才能通过。与漏桶不同，令牌桶允许一定程度的突发——桶中累积的令牌可被一次性取走。

// Go 标准库令牌桶使用示例
import "golang.org/x/time/rate"

limiter := rate.NewLimiter(rate.Limit(100), 200) // 速率 100/s，桶容量 200
if limiter.Allow() {
    // 处理请求
} else {
    // 限流拒绝
}

5. 四种算法综合对比

6. 选型建议与 Go 实践

• API 网关 / HTTP 服务：优先选择令牌桶（x/time/rate），支持突发且 Go 官方维护。
• 数据库连接池 / 消息队列消费：推荐漏桶，强制平滑输出，避免下游被冲垮。
• 简单场景 / 原型验证：计数器算法足够，但需注意临界突变对尾延迟的影响。
• 高精度限流（如 1ms 粒度）：滑动窗口配合原子操作，避免锁竞争。