go语言中实现http请求限流可防止服务过载，常用方法包括：1. 使用golang.org/x/time/rate的rate.Limiter实现单机令牌桶限流；2. 基于IP的独立限流，通过sync.RWMutex保护map存储各IP对应的限流器；3. 分布式场景下利用redis+lua脚本实现原子性漏桶或滑动窗口限流；4. 将限流逻辑封装为中间件，返回429状态码与Retry-After头，结合日志监控。根据部署规模选择合适策略，关键在于合理设置阈值并保障系统可观测性。
在go语言中实现HTTP请求限流，主要是为了防止服务被过多请求压垮，保护后端资源。限流策略可以通过控制单位时间内的请求数来实现。Golang标准库和第三方包都提供了良好的支持，下面介绍几种常见且实用的限流方法。
使用golang.org/x/time/rate进行基础限流
rate.Limiter 是 Go 官方提供的令牌桶限流器，位于 red”>golang.org/x/time/rate 包中，适合用于单机场景下的限流。
基本思路是：每个请求需要从令牌桶中获取一个令牌，若没有可用令牌则拒绝或等待。
示例代码：
立即学习“go语言免费学习笔记（深入）”；
package main import ( "golang.org/x/time/rate" "net/http" "time" ) var limiter = rate.NewLimiter(10, 50) // 每秒10个令牌，最多容纳50个突发请求 func limit(next http.HandlerFunc) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { if !limiter.Allow() { http.StatusText(http.StatusTooManyRequests) http.Error(w, "Too Many Requests", http.StatusTooManyRequests) return } next(w, r) } } func handler(w http.ResponseWriter, r *http.Request) { w.Write([]byte("Hello, Rate Limited World!")) } func main() { mux := http.NewServeMux() mux.HandleFunc("/", limit(handler)) http.ListenAndServe(":8080", mux) }
上面的例子中，每秒最多处理10个请求，允许最多50个突发请求。超过则返回429状态码。
基于IP的独立限流
实际应用中，通常需要对不同客户端（如IP）分别限流，而不是全局统一限制。
可以使用 map + sync.RWMutex 或第三方并发安全map来存储每个IP对应的限流器。
示例：
type IpLimiter struct { visitors map[string]*rate.Limiter mu *sync.RWMutex limit rate.Limit burst int } func NewIpLimiter(r rate.Limit, b int) *IpLimiter { return &IpLimiter{ visitors: make(map[string]*rate.Limiter), mu: &sync.RWMutex{}, limit: r, burst: b, } } func (i *IpLimiter) getLimiter(ip string) *rate.Limiter { i.mu.RLock() limiter, exists := i.visitors[ip] i.mu.RUnlock() if !exists { i.mu.Lock() // 再次检查，避免重复创建 if _, found := i.visitors[ip]; !found { i.visitors[ip] = rate.NewLimiter(i.limit, i.burst) } limiter = i.visitors[ip] i.mu.Unlock() } return limiter }
中间件中使用：
var ipLimiter = NewIpLimiter(1, 5) // 每秒1个请求，最多5个突发 func ipLimit(next http.HandlerFunc) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { ip := r.RemoteAddr // 实际使用时建议解析 X-Forwarded-For 或 X-Real-IP if !ipLimiter.getLimiter(ip).Allow() { http.Error(w, "Too Many Requests", http.StatusTooManyRequests) return } next(w, r) } }
使用redis实现分布式限流
在多实例部署场景下，单机内存无法共享限流状态，需借助Redis实现分布式限流。
常用算法是**漏桶算法**或**滑动窗口**，可使用 Redis 的 Lua 脚本保证原子性。
例如，使用 Redis 记录每个IP的请求次数和时间戳，通过脚本实现固定窗口限流：
local key = KEYS[1] local limit = tonumber(ARGV[1]) local window = tonumber(ARGV[2]) local current = redis.call("INCR", key) if current == 1 then redis.call("EXPIRE", key, window) end if current > limit then return 0 end return 1
Go中调用：
import "github.com/gomodule/redigo/redis" func allowRequest(ip string, conn redis.Conn) (bool, error) { script := redis.NewScript(1, ` local current = redis.call("INCR", KEYS[1]) if current == 1 then redis.call("EXPIRE", KEYS[1], ARGV[2]) end if current > tonumber(ARGV[1]) then return 0 end return 1 `) result, err := redis.Int(script.Do(conn, ip, "10", "60")) // 每分钟最多10次 if err != nil { return false, err } return result == 1, nil }
结合中间件与优雅错误处理
将限流逻辑封装成中间件，便于复用。同时应返回标准的限流响应头，如 Retry-After，帮助客户端重试。
建议做法：
- 返回429状态码
- 添加
Retry-After: 1头信息 - 记录日志以便监控异常流量
示例：
if !limiter.Allow() { w.Header().Set("Retry-After", "1") http.Error(w, "Rate limit exceeded", http.StatusTooManyRequests) return }
基本上就这些。根据系统规模选择合适的限流方式：单机用rate.Limiter，分布式的用Redis+Lua脚本。关键是设计合理阈值，并做好监控告警。不复杂但容易忽略细节。