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脚本。关键是设计合理阈值，并做好监控告警。不复杂但容易忽略细节。
