2、Go限流基础：令牌桶算法原理、漏桶算法原理、计数器算法原理

限流是保障高并发系统稳定性的第一道防线。在Go语言微服务架构中，限流算法直接决定了流量整形与突发处理的能力。本章深入剖析三种经典限流算法的核心原理、数学模型、适用场景及Go实现要点，为后续的熔断骨架审计奠定理论基础。

2.1 计数器算法（Counter Algorithm）

计数器算法是最直观的限流实现，基于固定时间窗口内的请求计数进行控制。

2.1.1 原理与数学模型

• 核心机制：将时间划分为固定的窗口（如1秒），每个窗口维护一个计数器。请求到达时计数器加1，若计数器超过阈值则拒绝请求。窗口结束时计数器重置。
• 临界问题：在窗口边界处可能出现流量突刺——窗口末期的突发请求与下一窗口初期的突发请求叠加，导致实际瞬时QPS达到阈值的2倍。

2.1.2 Go实现骨架

type CounterLimiter struct {
    rate     int64         // 阈值
    interval time.Duration // 窗口大小
    count    int64         // 当前计数
    lastTime time.Time     // 窗口起始时间
    mu       sync.Mutex
}

func (l *CounterLimiter) Allow() bool {
    l.mu.Lock()
    defer l.mu.Unlock()
    now := time.Now()
    if now.Sub(l.lastTime) >= l.interval {
        l.count = 0
        l.lastTime = now
    }
    if l.count >= l.rate {
        return false
    }
    l.count++
    return true
}

2.2 漏桶算法（Leaky Bucket Algorithm）

漏桶算法将请求视为水滴，通过固定速率漏出的桶来平滑流量，强制输出速率恒定。

2.2.1 原理与数学模型

• 核心机制：桶有固定容量，请求以任意速率注入桶中。桶底部以恒定速率漏水（处理请求）。若桶已满，新请求被丢弃。
• 关键特性：输出速率严格恒定，适合需要绝对平滑流量的场景（如数据库写入、下游限流保护）。
• 突发处理：桶容量允许一定程度的突发请求被缓存，但输出速率不变。

2.2.2 Go实现骨架

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

func (l *LeakyBucket) Allow() bool {
    l.mu.Lock()
    defer l.mu.Unlock()
    nowMs := time.Now().UnixMilli()
    elapsed := float64(nowMs - l.lastLeakMs) / 1000.0
    l.water = math.Max(0, l.water - elapsed * l.rate)
    l.lastLeakMs = nowMs
    if l.water < float64(l.capacity) {
        l.water++
        return true
    }
    return false
}

2.3 令牌桶算法（Token Bucket Algorithm）

令牌桶算法是业界最广泛使用的限流算法，Go标准库 golang.org/x/time/rate 即基于此实现。它允许一定程度的突发流量，同时保证长期平均速率。

2.3.1 原理与数学模型

• 核心机制：系统以恒定速率向桶中放入令牌。每个请求需消耗一个令牌才能被处理。桶有最大容量，超出部分令牌被丢弃。
• 突发能力：桶中累积的令牌数决定了最大突发请求量。若桶满，可一次性处理与桶容量相等的突发请求。
• 与漏桶对比：令牌桶允许输出速率短时超过平均速率（突发），而漏桶强制输出速率恒定。

2.3.2 Go标准库实现

import "golang.org/x/time/rate"

// 创建限流器：每秒产生100个令牌，桶容量200
limiter := rate.NewLimiter(100, 200)

// 每次请求前调用
if limiter.Allow() {
    // 处理请求
} else {
    // 限流拒绝
}

// 或使用 Wait() 阻塞等待令牌
err := limiter.Wait(ctx) // 可设置超时上下文

2.4 三种算法对比总结