2. Go 限流核心原理：令牌桶、漏桶、计数器算法实现对比

限流是保障分布式系统稳定性的第一道防线。Go 语言凭借其轻量级 Goroutine 和丰富的标准库，成为实现限流算法的理想平台。本章深入剖析三种经典限流算法——令牌桶、漏桶、计数器——在 Go 中的实现原理、代码结构及性能特征，为后续的尾延迟压测诊断奠定理论基础。

2.1 令牌桶算法（Token Bucket）

令牌桶是 Go 标准库 golang.org/x/time/rate 的底层实现，也是业界最广泛使用的限流模型。其核心思想是：系统以恒定速率向桶中放入令牌，每个请求必须获取一个令牌才能被处理；桶有容量上限，允许积累一定数量的令牌以应对突发流量。

2.1.1 算法数学模型

• 桶容量（burst）： 桶最多容纳的令牌数，决定了最大突发请求量。
• 填充速率（rate）： 每秒向桶中放入的令牌数，即长期平均请求速率。
• 当前令牌数（tokens）： 动态变化的可用令牌数量。
• 最后填充时间（lastTime）： 上次更新令牌数的时间戳，用于计算应补充的令牌。

2.1.2 Go 核心实现

type TokenBucket struct {
    rate       float64       // 令牌填充速率（个/秒）
    capacity   float64       // 桶容量
    tokens     float64       // 当前令牌数
    lastTime   time.Time     // 上次填充时间
    mu         sync.Mutex    // 并发安全
}

func NewTokenBucket(rate, capacity float64) *TokenBucket {
    return &TokenBucket{
        rate:     rate,
        capacity: capacity,
        tokens:   capacity,   // 初始满桶
        lastTime: time.Now(),
    }
}

func (tb *TokenBucket) Allow() bool {
    tb.mu.Lock()
    defer tb.mu.Unlock()

    now := time.Now()
    elapsed := now.Sub(tb.lastTime).Seconds()
    // 补充令牌：时间差 × 速率
    tb.tokens += elapsed * tb.rate
    if tb.tokens > tb.capacity {
        tb.tokens = tb.capacity
    }
    tb.lastTime = now

    if tb.tokens >= 1 {
        tb.tokens--
        return true
    }
    return false
}

2.1.3 令牌桶算法流程

2.2 漏桶算法（Leaky Bucket）

漏桶算法将请求视为水滴，以恒定速率从桶底漏出；桶满时新请求被丢弃。与令牌桶不同，漏桶强制输出速率绝对平滑，不允许任何突发，适合需要严格整形流量的场景（如数据库连接池、消息队列消费端）。

2.2.1 算法数学模型

• 桶容量（capacity）： 最多容纳的请求数（等待队列长度）。
• 漏出速率（leakRate）： 每秒从桶底漏出的请求数，即处理速率。
• 当前水位（water）： 桶中当前等待处理的请求数。
• 上次漏水时间（lastLeakTime）： 用于计算应漏出的水量。

2.2.2 Go 核心实现

type LeakyBucket struct {
    capacity      float64       // 桶容量
    leakRate      float64       // 漏水速率（个/秒）
    water         float64       // 当前水位
    lastLeakTime  time.Time     // 上次漏水时间
    mu            sync.Mutex
}

func NewLeakyBucket(capacity, leakRate float64) *LeakyBucket {
    return &LeakyBucket{
        capacity:     capacity,
        leakRate:     leakRate,
        water:        0,
        lastLeakTime: time.Now(),
    }
}

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

    now := time.Now()
    elapsed := now.Sub(lb.lastLeakTime).Seconds()
    // 先漏水：水位下降
    lb.water -= elapsed * lb.leakRate
    if lb.water < 0 {
        lb.water = 0
    }
    lb.lastLeakTime = now

    // 判断是否超过容量
    if lb.water < lb.capacity {
        lb.water++
        return true
    }
    return false
}

2.2.3 漏桶算法流程

2.3 计数器算法（Counter / Fixed Window）

计数器算法是最直观的限流方式：在固定时间窗口（如 1 秒）内统计请求数，超过阈值则拒绝。实现简单，但存在窗口边界突刺问题——在窗口切换瞬间可能涌入两倍阈值的请求。

2.3.1 算法数学模型

• 时间窗口（window）： 固定的统计周期，通常为 1 秒。
• 阈值（limit）： 每个窗口内允许的最大请求数。
• 当前计数（count）： 当前窗口内的请求累计值。
• 窗口起始时间（startTime）： 当前窗口的开始时刻。

2.3.2 Go 核心实现

type CounterLimiter struct {
    limit     int64         // 窗口内最大请求数
    window    time.Duration // 时间窗口
    count     int64         // 当前计数
    startTime time.Time     // 窗口起始时间
    mu        sync.Mutex
}

func NewCounterLimiter(limit int64, window time.Duration) *CounterLimiter {
    return &CounterLimiter{
        limit:     limit,
        window:    window,
        count:     0,
        startTime: time.Now(),
    }
}

func (cl *CounterLimiter) Allow() bool {
    cl.mu.Lock()
    defer cl.mu.Unlock()

    now := time.Now()
    // 如果超过窗口时间，重置计数器
    if now.Sub(cl.startTime) >= cl.window {
        cl.count = 0
        cl.startTime = now
    }

    if cl.count < cl.limit {
        cl.count++
        return true
    }
    return false
}

2.4 三种算法对比总结

2.5 选型建议与性能考量

在后续的尾延迟压测诊断中，我们将看到：

• 令牌桶在突发流量下表现最佳，尾延迟抖动最小。
• 漏桶在恒定负载下延迟稳定，但突发时会导致大量请求被拒，加剧客户端重试风暴。
• 计数器实现简单，但窗口边界处的延迟尖刺可达正常值的 2-3 倍，是尾延迟恶化的常见原因。