答案：Golang中常用限流方式包括令牌桶算法、基于IP的限流、中间件封装及分布式限流。1. 使用golang.org/x/time/rate实现令牌桶限流，控制请求速率；2. 结合sync.RWMutex或sync.Map对不同IP独立限流；3. 将限流逻辑封装为HTTP中间件提升复用性；4. 多实例环境下采用Redis+Lua实现分布式滑动窗口限流；需注意内存泄漏风险，合理设置清理机制。
在高并发的 Web 服务中，限流是保护系统稳定性的重要手段。Golang 因其高效的并发模型，常被用于构建高性能后端服务，因此掌握在 Go 中实现 Web 请求限流的方法非常关键。以下是几种常见的 Golang Web 请求限流实现方式，适用于不同场景。
1. 使用令牌桶算法（Token Bucket）
令牌桶是一种经典的限流算法，允许突发流量在一定范围内通过，同时控制平均速率。
Go 标准库中的 red">golang.org/x/time/rate 包提供了基于令牌桶的限流器 rate.Limiter，使用简单且线程安全。
示例代码：
立即学习“go语言免费学习笔记（深入）”；
package mainimport ( "golang.org/x/time/rate" "net/http" "time" )
var limiter = rate.NewLimiter(10, 50) // 每秒10个令牌，最多容纳50个
func handler(w http.ResponseWriter, r *http.Request) { if !limiter.Allow() { http.Error(w, "Too Many Requests", http.StatusTooManyRequests) return } w.Write([]byte("Request processed")) }
func main() { http.HandleFunc("/", handler) http.ListenAndServe(":8080", nil) }
说明：每秒生成10个令牌，最多积压50个。超出则返回 429 状态码。
2. 基于 IP 的限流
实际应用中通常需要对不同客户端分别限流。可以结合 map + rate.Limiter 实现按 IP 限流。
注意：需使用互斥锁保护 map，或使用 sync.Map。
示例：
var ipLimiters = struct {
sync.RWMutex
m map[string]*rate.Limiter
}{m: make(map[string]*rate.Limiter)}
func getLimiter(ip string) *rate.Limiter {
ipLimiters.RLock()
limiter, exists := ipLimiters.m[ip]
ipLimiters.RUnlock()
if !exists {
ipLimiters.Lock()
// 双检避免重复创建
if limiter == nil {
limiter = rate.NewLimiter(5, 10) // 每个IP每秒5次
ipLimiters.m[ip] = limiter
}
ipLimiters.Unlock()
}
return limiter}
func limitedHandler(w http.ResponseWriter, r *http.Request) {
ip := r.RemoteAddr
if !getLimiter(ip).Allow() {
http.Error(w, "Rate limit exceeded", http.StatusTooManyRequests)
return
}
w.Write([]byte("Hello from " + ip))
}
3. 使用中间件统一限流
将限流逻辑封装为 HTTP 中间件，便于复用和管理。
示例中间件：
func rateLimit(next http.HandlerFunc) http.HandlerFunc {
limiter := rate.NewLimiter(10, 50)
return func(w http.ResponseWriter, r *http.Request) {
if !limiter.Allow() {
http.Error(w, "Rate limit exceeded", http.StatusTooManyRequests)
return
}
next(w, r)
}
}
// 使用
http.HandleFunc("/", rateLimit(handler))
也可以扩展为支持配置参数的中间件工厂。
4. 分布式限流（Redis + Lua）
单机限流无法应对多实例部署。可借助 Redis 实现分布式令牌桶或滑动窗口限流。
常用方案：使用 Redis 存储请求时间戳，通过 Lua 脚本保证原子性。
滑动窗口 Lua 示例（限制每秒最多10次）：
-- KEYS[1]: key, ARGV[1]: current time (ms), ARGV[2]: limit count
local key = KEYS[1]
local now = tonumber(ARGV[1])
local limit = tonumber(ARGV[2])
local window = 1000 -- 1秒窗口
redis.call('ZREMRANGEBYSCORE', key, 0, now - window)
local count = redis.call('ZCARD', key)
if count < limit then
redis.call('ZADD', key, now, now)
redis.call('EXPIRE', key, 1)
return 1
else
return 0
end
Go 中调用：
script := redis.NewScript(luaScript)
result, err := script.Run(ctx, client, []string{ipKey}, time.Now().UnixMilli(), 10).Int()
if err != nil || result == 0 {
// 被限流
}
基本上就这些常见方法。根据业务规模选择：单机用 rate.Limiter，按 IP 限流加 map 缓存，集群环境上 Redis 方案。实现时注意内存泄漏（如无限增长的 IP 记录），可定期清理或使用 LRU 缓存。不复杂但容易忽略细节。
