接口限流算法实战：令牌桶、漏桶与滑动窗口的Go语言实现

五、令牌桶算法（Token Bucket）

令牌桶算法是实践中最常用的限流算法。系统以固定速率向桶中添加令牌，每个请求需要消耗一个令牌。如果桶为空且令牌不足，请求被拒绝。

特点：允许突发流量（只要桶中有足够的令牌），同时限制了平均速率。这是API网关（如Redis的redis-cell模块）常用的算法。

package main

import (
    "fmt"
    "sync"
    "time"
)

// TokenBucketLimiter 令牌桶限流器
type TokenBucketLimiter struct {
    capacity   int           // 桶最大容量
    rate       float64       // 令牌生成速率（每秒）
    tokens     float64       // 当前令牌数
    lastRefill time.Time     // 上次补充令牌时间
    mu         sync.Mutex
}

func NewTokenBucketLimiter(capacity int, rate float64) *TokenBucketLimiter {
    return &TokenBucketLimiter{
        capacity:   capacity,
        rate:       rate,
        tokens:     float64(capacity), // 初始满桶
        lastRefill: time.Now(),
    }
}

func (t *TokenBucketLimiter) Allow() bool {
    return t.AllowN(1)
}

// AllowN 尝试消耗n个令牌
func (t *TokenBucketLimiter) AllowN(n int) bool {
    t.mu.Lock()
    defer t.mu.Unlock()

    t.refill()

    if float64(n) > t.tokens {
        return false
    }

    t.tokens -= float64(n)
    return true
}

// refill 补充令牌
func (t *TokenBucketLimiter) refill() {
    now := time.Now()
    elapsed := now.Sub(t.lastRefill).Seconds()
    tokensToAdd := elapsed * t.rate
    t.tokens += tokensToAdd
    if t.tokens > float64(t.capacity) {
        t.tokens = float64(t.capacity)
    }
    t.lastRefill = now
}

// Wait 等待直到获取令牌，返回等待时间
func (t *TokenBucketLimiter) Wait(n int) time.Duration {
    t.mu.Lock()
    defer t.mu.Unlock()

    t.refill()

    if t.tokens >= float64(n) {
        t.tokens -= float64(n)
        return 0
    }

    // 计算需要等待的时间
    deficit := float64(n) - t.tokens
    waitTime := time.Duration(deficit/t.rate*1000) * time.Millisecond
    t.tokens = 0
    t.lastRefill = t.lastRefill.Add(waitTime)
    return waitTime
}

func main() {
    // 桶容量50，每秒生成10个令牌
    limiter := NewTokenBucketLimiter(50, 10)

    // 测试突发消费
    fmt.Println("=== 令牌桶突发消费测试 ===")
    for i := 0; i < 15>