使用golang.org/x/time/rate实现每分钟N次请求限流的问题

需求 #

实现一个允许每分钟n次请求的限流器。

尝试方案 #

初始化阶段创建限流器：

// 初始化过程中某处
limiter = rate.NewLimiter(rate.Every(1*time.Minute/2), 2)

在HTTP服务器中间件中使用：

func (self *Router) limiterMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(responseWriter http.ResponseWriter, request *http.Request) {
        if !limiter.Allow(){
            http.Error(responseWriter, "Too many requests", http.StatusTooManyRequests)
            return
        }

        next.ServeHTTP(responseWriter, request)
    })
}

预期结果 #

前两次请求成功；后续请求返回HTTP429，直到1分钟后第一个请求的配额释放，可再处理一次请求；之后需再等1分钟释放第二个请求的配额，才能处理下一次请求。

实际结果 #

初始两次请求成功后，第三次成功请求在30秒后出现，即30秒内共处理了3次请求；第四次成功请求在又一个30秒后出现。若将burst设为1，则初始仅1次请求成功，每30秒可处理一次请求。

疑问 #

如何正确配置限流器以实现每分钟n次请求的需求？是否该包无法实现此功能，需更换其他库？

问题本质：混淆了两种限流模型 #

你当前的困惑源于对令牌桶算法和滑动窗口限流的差异理解不清：

• golang.org/x/time/rate 实现的是令牌桶算法，核心是控制平均请求速率，允许初始突发请求，之后按固定速率补充令牌。你配置的rate.Every(1*time.Minute/2)意味着每30秒生成1个令牌，burst=2是初始有2个令牌，所以前两次请求直接用掉初始令牌，之后每30秒补充1个，对应你看到的“每30秒处理一次后续请求”的结果，这是令牌桶的正常表现。
• 你的预期是滑动窗口限流的效果：严格保证任意连续1分钟内的请求数不超过n次，不允许短时间内突破速率限制。

针对性解决方案 #

1. 若需求是「平均每分钟n次，允许初始突发」

你的原配置本身是正确的，实际结果符合令牌桶算法的预期，不需要更换库。如果想取消初始突发，让请求严格按速率执行，把burst参数设为1即可：

// 以每分钟2次为例，burst=1时，初始1个令牌，每30秒补充1个，每30秒仅能处理1次请求
limiter = rate.NewLimiter(rate.Every(time.Minute/2), 1)

2. 若需求是「任意1分钟内最多n次」

rate包无法直接实现滑动窗口限流，你可以自己实现简单的滑动窗口逻辑，示例如下：

首先定义滑动窗口限流器：

import (
    "sync"
    "time"
)

type SlidingWindowLimiter struct {
    mu         sync.Mutex
    maxRequest int
    window     time.Duration
    timestamps []time.Time
}

func NewSlidingWindowLimiter(maxReq int, window time.Duration) *SlidingWindowLimiter {
    return &SlidingWindowLimiter{
        maxRequest: maxReq,
        window:     window,
    }
}

func (l *SlidingWindowLimiter) Allow() bool {
    l.mu.Lock()
    defer l.mu.Unlock()

    now := time.Now()
    cutoff := now.Add(-l.window)
    // 移除窗口外的历史请求时间戳
    idx := 0
    for ; idx < len(l.timestamps); idx++ {
        if l.timestamps[idx].After(cutoff) {
            break
        }
    }
    l.timestamps = l.timestamps[idx:]

    // 检查当前窗口内请求数是否超限
    if len(l.timestamps) < l.maxRequest {
        l.timestamps = append(l.timestamps, now)
        return true
    }
    return false
}

然后在中间件中使用：

func (self *Router) limiterMiddleware(next http.Handler) http.Handler {
    // 初始化：每分钟最多2次请求
    limiter := NewSlidingWindowLimiter(2, time.Minute)
    return http.HandlerFunc(func(responseWriter http.ResponseWriter, request *http.Request) {
        if !limiter.Allow() {
            http.Error(responseWriter, "Too many requests", http.StatusTooManyRequests)
            return
        }
        next.ServeHTTP(responseWriter, request)
    })
}

这个实现会严格符合你的预期：前两次请求成功后，后续请求会被拦截直到1分钟窗口过期，之后每过1分钟才能依次释放新的请求配额。

内容的提问来源于stack exchange，提问作者user826955