Golang通过令牌桶算法、中间件限流和Redis分布式限流实现高并发保护。使用rate.Limiter控制单机请求速率，结合IP限流中间件隔离用户资源，利用Redis+Lua实现跨节点滑动窗口限流，需合理配置阈值并返回429状态码，兼顾系统稳定与用户体验。
在高并发场景下，Golang 处理网络请求时如果没有限流机制，容易导致服务过载甚至崩溃。合理的限流策略可以保护后端资源，保障系统稳定性。Golang 本身简洁高效的并发模型非常适合实现限流逻辑，本文将详细介绍几种常见的限流方法及其实践方式。
使用令牌桶算法实现限流
令牌桶算法是限流中最常用的策略之一。它允许请求在一定范围内“突发”处理，同时控制平均速率。Golang 标准库 golang.org/x/time/rate 提供了基于令牌桶的限流器 rate.Limiter，使用非常方便。
示例代码：
package main
<p>import (
"fmt"
"net/http"
"time"
"golang.org/x/time/rate"
)</p><p>var limiter = rate.NewLimiter(1, 5) // 每秒1个令牌，初始容量5</p><p><span>立即学习</span>“<a href="https://pan.quark.cn/s/00968c3c2c15" style="text-decoration: underline !important; color: blue; font-weight: bolder;" rel="nofollow" target="_blank">go语言免费学习笔记（深入）</a>”；</p><p>func handler(w http.ResponseWriter, r *http.Request) {
if !limiter.Allow() {
http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
return
}
fmt.Fprintf(w, "Request processed at %v", time.Now())
}</p><p>func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}</p>上面的例子中，每秒只允许1个请求通过，但最多可缓存5个请求（burst=5），适合应对短时间内的流量高峰。
中间件方式统一限流
在实际项目中，通常会将限流逻辑封装为 HTTP 中间件，便于复用和管理。
示例：基于 IP 的限流中间件
type ClientLimiter struct {
ips map[string]*rate.Limiter
mu *sync.RWMutex
r rate.Limit
b int
}
<p>func NewClientLimiter(r rate.Limit, b int) <em>ClientLimiter {
return &ClientLimiter{
ips: make(map[string]</em>rate.Limiter),
mu: &sync.RWMutex{},
r: r,
b: b,
}
}</p><p>func (cl <em>ClientLimiter) GetLimiter(ip string) </em>rate.Limiter {
cl.mu.Lock()
defer cl.mu.Unlock()</p><pre class='brush:php;toolbar:false;'>limiter, exists := cl.ips[ip]
if !exists {
limiter = rate.NewLimiter(cl.r, cl.b)
cl.ips[ip] = limiter
}
return limiter}
func limitMiddleware(limiter ClientLimiter) func(http.Handler) http.Handler { return func(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { ip := r.RemoteAddr if !limiter.GetLimiter(ip).Allow() { http.Error(w, "Too Many Requests", http.StatusTooManyRequests) return } next.ServeHTTP(w, r) }) } }
通过该中间件，每个客户端 IP 独立拥有一个限流器，避免单个用户耗尽系统资源。
结合 Redis 实现分布式限流
单机限流适用于单一服务实例，但在微服务或多节点部署中，需要分布式限流。此时可借助 Redis 和 Lua 脚本实现原子化的令牌桶或滑动窗口限流。
常用方案：
- 使用 Redis 存储每个用户的请求计数和时间戳
- 通过 Lua 脚本保证操作的原子性
- 采用滑动窗口算法更精确地统计单位时间请求数
示例思路（伪代码）：
-- KEYS[1] = 用户标识
-- ARGV[1] = 当前时间戳（秒）
-- ARGV[2] = 窗口大小（如60秒）
-- ARGV[3] = 最大请求数
<p>redis.call('ZREMRANGEBYSCORE', KEYS[1], 0, ARGV[1] - ARGV[2])
local current = redis.call('ZCARD', KEYS[1])
if current < tonumber(ARGV[3]) then
redis.call('ZADD', KEYS[1], ARGV[1], ARGV[1])
return 1
else
return 0
end</p>Golang 中可通过 go-redis/redis 客户端执行该脚本，实现跨节点一致的限流控制。
合理配置限流参数
限流不是越严越好，需根据业务特点设定合理阈值：
- 公开 API 可设置较低速率，如 10次/秒/IP
- 登录用户可适当提高配额
- 内部服务调用可放宽限制，但仍建议保留基本防护
- 配合监控告警，动态调整策略
同时建议返回正确的 HTTP 状态码（如 429）和重试头（Retry-After），提升客户端体验。
基本上就这些。Golang 凭借其强大的标准库和生态，能轻松实现从单机到分布式的多种限流方案。关键是根据实际场景选择合适算法，并做好可观测性支持。不复杂但容易忽略细节，比如清除过期客户端状态、防止内存泄漏等，都需要在生产环境中特别注意。
