4. 漏桶算法实现：Go 语言手写漏桶算法、基于 channel 的异步漏桶、与令牌桶的对比

漏桶算法是限流领域最直观的“恒定速率”模型。与令牌桶允许突发不同，漏桶强制输出速率完全平滑，适合需要严格削峰填谷的场景。本节将手写两种漏桶实现，并与令牌桶进行多维对比。

4.1 漏桶算法核心原理

漏桶算法将请求视为水滴，桶底以固定速率漏水（处理请求）。当桶满时，新请求被丢弃。其核心参数只有两个：桶容量（最大积压请求数）和漏水速率（每秒处理请求数）。

4.2 手写漏桶：同步实现

同步漏桶使用互斥锁保护桶状态，每次请求时检查桶是否已满，未满则加入桶并启动漏水协程。

type LeakyBucket struct {
    capacity   int           // 桶容量
    rate       time.Duration // 每滴水的间隔
    queue      chan struct{} // 请求队列（channel 实现）
    mu         sync.Mutex
    lastLeak   time.Time
    waterLevel int
}

func NewLeakyBucket(capacity int, ratePerSec int) *LeakyBucket {
    interval := time.Second / time.Duration(ratePerSec)
    lb := &LeakyBucket{
        capacity: capacity,
        rate:     interval,
        queue:    make(chan struct{}, capacity),
    }
    go lb.leak()
    return lb
}

func (lb *LeakyBucket) leak() {
    ticker := time.NewTicker(lb.rate)
    defer ticker.Stop()
    for range ticker.C {
        select {
        case <-lb.queue:
            // 漏水：取出一个请求
        default:
            // 队列为空，跳过
        }
    }
}

func (lb *LeakyBucket) Allow() bool {
    select {
    case lb.queue <- struct{}{}:
        return true
    default:
        return false // 桶满，拒绝
    }
}

4.3 基于 channel 的异步漏桶

异步漏桶将请求处理与漏水逻辑完全解耦，适合高并发场景。请求先进入 channel 缓冲，漏水协程以固定速率消费。

type AsyncLeakyBucket struct {
    requests chan func()  // 请求函数通道
    capacity int
    rate     time.Duration
    wg       sync.WaitGroup
}

func NewAsyncLeakyBucket(capacity int, ratePerSec int) *AsyncLeakyBucket {
    alb := &AsyncLeakyBucket{
        requests: make(chan func(), capacity),
        capacity: capacity,
        rate:     time.Second / time.Duration(ratePerSec),
    }
    go alb.processLoop()
    return alb
}

func (alb *AsyncLeakyBucket) processLoop() {
    ticker := time.NewTicker(alb.rate)
    defer ticker.Stop()
    for range ticker.C {
        select {
        case task := <-alb.requests:
            alb.wg.Add(1)
            go func(fn func()) {
                defer alb.wg.Done()
                fn() // 异步执行请求处理
            }(task)
        default:
            // 无待处理请求
        }
    }
}

func (alb *AsyncLeakyBucket) Submit(task func()) bool {
    select {
    case alb.requests <- task:
        return true
    default:
        return false // 桶满，拒绝
    }
}

func (alb *AsyncLeakyBucket) Wait() {
    alb.wg.Wait()
}

4.4 漏桶与令牌桶的全面对比

4.5 选型建议与避坑指南

• 数据库写入限流：优先选漏桶。数据库连接池和磁盘 I/O 对突发写入敏感，漏桶的恒定输出能避免连接池打满。
• API 网关限流：优先选令牌桶。允许突发请求通过，避免正常用户的短时高频请求被误杀。
• 视频流/直播推流：必须用漏桶。视频编码器要求恒定码率输入，突发会导致编码器缓冲溢出。
• 日志采集：推荐异步漏桶。日志产生速度波动大，异步漏桶能平滑写入后端存储。

4.6 性能压测对比数据