当前位置：首页 > news >正文

【Golang面试题】Go语言实现请求频率限制

news 来源：原创 2025/6/21 10:50:53

Go语言实现请求频率限制：从计数器到令牌桶的完整指南

在实际开发中，接口被恶意刷请求是常见问题。本文将深入探讨Go语言中四种主流的请求限流方案，从简单到复杂逐步深入，助你构建高可用服务。

一、基础方案：计数器法（固定窗口）

适用场景：简单业务、低并发需求


type CounterLimiter struct {mu       sync.Mutexcount    intinterval time.DurationmaxReq   intlastReset time.Time
}func NewCounterLimiter(interval time.Duration, maxReq int) *CounterLimiter {return &CounterLimiter{interval:  interval,maxReq:    maxReq,lastReset: time.Now(),}
}func (c *CounterLimiter) Allow() bool {c.mu.Lock()defer c.mu.Unlock()// 检查是否需要重置计数器if time.Since(c.lastReset) > c.interval {c.count = 0c.lastReset = time.Now()}// 检查是否超过限制if c.count >= c.maxReq {return false}c.count++return true
}// HTTP中间件示例
func RateLimitMiddleware(limiter *CounterLimiter) func(http.Handler) http.Handler {return func(next http.Handler) http.Handler {return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {if !limiter.Allow() {w.Header().Set("Retry-After", "60")http.Error(w, "Too Many Requests", http.StatusTooManyRequests)return}next.ServeHTTP(w, r)})}
}

优点：

实现简单，内存占用低
无第三方依赖

缺点：

窗口边界突发流量问题
分布式场景不适用

二、进阶方案：Redis滑动窗口

适用场景：分布式系统、精确限流

const luaScript = `
local key = KEYS[1]
local now = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local max = tonumber(ARGV[3])redis.call('ZREMRANGEBYSCORE', key, 0, now - window)
local current = redis.call('ZCARD', key)if current >= max thenreturn 0
endredis.call('ZADD', key, now, now)
redis.call('EXPIRE', key, math.ceil(window/1000))
return 1
`type RedisLimiter struct {client   *redis.Clientscript   *redis.ScriptmaxReq   intwindow   time.Duration
}func NewRedisLimiter(client *redis.Client, window time.Duration, maxReq int) *RedisLimiter {return &RedisLimiter{client: client,script: redis.NewScript(luaScript),maxReq: maxReq,window: window,}
}func (r *RedisLimiter) Allow(userID string) bool {ctx := context.Background()key := fmt.Sprintf("rate_limit:%s", userID)now := time.Now().UnixMilli()result, err := r.script.Run(ctx, r.client, []string{key}, now, r.window.Milliseconds(), r.maxReq).Int()return err == nil && result == 1
}

实现要点：

使用Redis有序集合存储时间戳
Lua脚本保证原子操作
自动清理过期请求
精确统计时间窗口内请求

优势：

精确的滑动窗口计数
分布式系统通用
自动处理数据过期

三、高级方案：令牌桶算法

适用场景：允许突发流量、精细控制

type TokenBucket struct {capacity    int           // 桶容量tokens      int           // 当前令牌数fillRate    time.Duration // 添加令牌间隔lastRefill  time.Time     // 上次添加时间mu          sync.Mutex
}func NewTokenBucket(capacity int, rate time.Duration) *TokenBucket {return &TokenBucket{capacity:   capacity,tokens:     capacity,fillRate:   rate,lastRefill: time.Now(),}
}func (b *TokenBucket) Allow() bool {b.mu.Lock()defer b.mu.Unlock()// 补充令牌now := time.Now()elapsed := now.Sub(b.lastRefill)newTokens := int(elapsed / b.fillRate)if newTokens > 0 {b.tokens += newTokensif b.tokens > b.capacity {b.tokens = b.capacity}b.lastRefill = now}// 检查令牌是否足够if b.tokens <= 0 {return false}b.tokens--return true
}

算法特点：

允许短时间内突发流量
精确控制平均速率
实现相对复杂

四、生产级方案：使用成熟中间件

推荐库：

Tollbooth
Uber-go/ratelimit

Tollbooth示例：


func main() {r := chi.NewRouter()// 创建限流器：每分钟1000次limiter := tollbooth.NewLimiter(1000/60.0, nil)limiter.SetIPLookups([]string{"X-Real-IP", "RemoteAddr", "X-Forwarded-For"})// 应用中间件r.Use(tollbooth_chi.LimitHandler(limiter))r.Get("/api/protected", func(w http.ResponseWriter, r *http.Request) {w.Write([]byte("Protected content"))})http.ListenAndServe(":8080", r)
}

五、方案选型指南

方案	实现复杂度	精准度	突发处理	分布式支持
计数器法	★☆☆☆☆	★★☆☆☆	差	否
Redis滑动窗口	★★★☆☆	★★★★★	中	是
令牌桶算法	★★★★☆	★★★★☆	允许突发	有限
限流中间件	★☆☆☆☆	★★★★☆	可配置	是

六、最佳实践

分层防御：
- 前端：按钮防重复点击
- 网关：基础IP限流
- 业务层：用户级精细控制

动态调整：

// 动态调整限流阈值
func adjustLimitBasedOnSystemLoad() {load := getSystemLoad()if load > 0.8 {limiter.SetMaxRequests(500) // 高负载时降低阈值}
}

熔断机制：

// 使用hystrix实现熔断
hystrix.ConfigureCommand("my_api", hystrix.CommandConfig{Timeout:               1000,MaxConcurrentRequests: 100,ErrorPercentThreshold: 50,
})