4. 漏桶算法：漏桶原理、uber-go/ratelimit 库解析、与令牌桶的对比

4.1 漏桶算法核心原理

漏桶算法（Leaky Bucket）是一种流量整形（Traffic Shaping）与限流算法。其核心思想是将请求视为水滴，系统视为一个底部有孔的固定容量水桶。无论进水速率如何波动，水桶都以恒定的速率从底部漏水（处理请求）。当水桶满时，新进入的水滴（请求）将被丢弃。

4.2 漏桶算法的数学模型

漏桶算法可以用以下参数描述：

算法执行流程：

1. 每个请求到达时，计算自上次漏水以来桶内应减少的水量：W = max(0, W - r * (now - lastTime))
2. 判断当前水量 W 是否小于桶容量 B：
   • 若 W < B，请求入桶，W = W + 1，请求被接受
   • 若 W >= B，请求被丢弃
3. 更新 lastTime = now

4.3 uber-go/ratelimit 库解析

Uber 开源的 go.uber.org/ratelimit 是 Go 语言中最流行的漏桶算法实现之一。它基于滑动时间窗口与松弛（slack）机制，提供了高性能的限流能力。

4.3.1 核心接口与使用

import (
    "go.uber.org/ratelimit"
    "time"
)

func main() {
    // 创建限流器：每秒 100 个请求
    limiter := ratelimit.New(100)

    for i := 0; i < 200; i++ {
        // Take() 会阻塞直到允许请求通过
        now := limiter.Take()
        // 处理业务逻辑
        _ = now
    }
}

4.3.2 内部实现原理

uber-go/ratelimit 的核心数据结构与算法：

Take() 方法执行逻辑：

1. 获取当前时间 now
2. 计算自上次请求以来的时间差：elapsed = now - state.last
3. 计算应睡眠时间：sleepFor = state.sleepFor - elapsed + perRequest
4. 若 sleepFor > 0，则睡眠 sleepFor 时间
5. 更新 state.last = now，state.sleepFor = sleepFor（受 maxSlack 约束）
6. 返回当前时间

4.3.3 松弛（Slack）机制

标准的漏桶算法在长时间空闲后，会允许瞬间通过大量请求（因为桶是空的）。uber-go/ratelimit 通过 maxSlack 参数限制这种突发行为：

• 默认行为： maxSlack = 10 * perRequest，即最多累积 10 个请求的松弛时间
• 作用： 防止客户端长时间不调用后，突然放行大量请求导致下游压力
• 配置方式： ratelimit.New(100, ratelimit.WithSlack(5))

4.4 漏桶算法与令牌桶算法对比

漏桶算法与令牌桶算法（Token Bucket）是两种最常用的限流算法，它们在设计哲学和适用场景上有显著差异。

4.4.1 选择建议

• 选择漏桶： 当需要严格保护下游系统，不允许任何突发流量时。例如：数据库写入限流、消息队列生产速率控制。
• 选择令牌桶： 当业务允许短时突发，且希望尽可能利用系统资源时。例如：HTTP API 限流、CDN 回源限流。

4.5 漏桶算法在 Go 中的手写实现

为加深理解，下面给出一个简洁的漏桶算法实现：

package leakybucket

import (
    "sync"
    "time"
)

type LeakyBucket struct {
    rate       float64       // 每秒处理速率
    capacity   float64       // 桶容量
    water      float64       // 当前水量
    lastLeakMs int64         // 上次漏水时间戳（毫秒）
    mu         sync.Mutex
}

func NewLeakyBucket(rate, capacity float64) *LeakyBucket {
    return &LeakyBucket{
        rate:       rate,
        capacity:   capacity,
        water:      0,
        lastLeakMs: time.Now().UnixMilli(),
    }
}

func (lb *LeakyBucket) Allow() bool {
    lb.mu.Lock()
    defer lb.mu.Unlock()

    now := time.Now().UnixMilli()
    // 计算自上次漏水以来应减少的水量
    elapsed := float64(now - lb.lastLeakMs) / 1000.0 // 转换为秒
    lb.water = max(0, lb.water - elapsed*lb.rate)
    lb.lastLeakMs = now

    // 判断是否允许请求
    if lb.water < lb.capacity {
        lb.water++
        return true
    }
    return false
}

func max(a, b float64) float64 {
    if a > b {
        return a
    }
    return b
}