第一章：限流golang
在高并发服务中，限流是保障系统稳定性的核心手段之一。Go 语言凭借其轻量级协程和高效并发模型，成为实现高性能限流器的理想选择。常见的限流算法包括计数器（Fixed Window）、滑动窗口（Sliding Window）、漏桶（Leaky Bucket）和令牌桶（Token Bucket），每种适用于不同场景：计数器实现简单但存在临界突变问题；滑动窗口更平滑但需维护时间切片；令牌桶则兼顾突发流量处理与长期速率控制。
令牌桶限流器实现
使用 golang.org/x/time/rate 包可快速构建生产级令牌桶限流器：
package main
import (
"fmt"
"time"
"golang.org/x/time/rate"
)
func main() {
// 每秒最多允许10个请求，初始令牌数为5（支持短时突发）
limiter := rate.NewLimiter(10, 5)
for i := 0; i < 15; i++ {
if limiter.Allow() { // 非阻塞检查
fmt.Printf("✅ 请求 %d 通过\n", i+1)
} else {
fmt.Printf("❌ 请求 %d 被拒绝\n", i+1)
}
time.Sleep(80 * time.Millisecond) // 模拟请求间隔
}
}该代码启动后将输出约10–12次“通过”，后续因令牌耗尽而被拒绝，直观体现令牌桶的速率控制与突发容忍特性。
自定义滑动窗口限流器要点
若需更高精度或分布式支持，可基于 sync.Map + 时间分片实现滑动窗口：
- 将当前时间按毫秒级切分为滑动窗口（如最近60秒）
- 使用
atomic计数器统计各时间片请求数 - 定期清理过期时间片（推荐用惰性清理而非定时 goroutine）
常见限流策略对比
| 算法 | 实现复杂度 | 突发流量支持 | 分布式友好 | 适用场景 |
|---|---|---|---|---|
| 计数器 | ★☆☆ | ❌ | ✅（需中心化存储） | 粗粒度QPS限制 |
| 滑动窗口 | ★★☆ | ✅ | ⚠️（需共享状态） | 中等精度、低延迟要求 |
| 令牌桶 | ★★☆ | ✅ | ✅（本地即可） | API网关、微服务入口 |
实际部署时，建议优先使用 rate.Limiter，再结合 Prometheus 暴露 rate_limit_exceeded_total 指标，实现可观测性闭环。
第二章：Go服务限流机制原理与主流实现方案选型
2.1 Go原生sync.Mutex与atomic在限流场景下的性能边界分析
数据同步机制
限流器核心需原子更新计数器并判断是否超限。sync.Mutex 提供强一致性但伴随锁竞争开销；atomic.Int64 则基于 CPU 原语，无锁但仅支持简单读写/比较交换。
性能对比实验（100万次并发请求）
| 实现方式 | 平均延迟（ns） | 吞吐量（QPS） | GC 压力 |
|---|---|---|---|
sync.Mutex |
820 | 1.2M | 中 |
atomic.Int64 |
18 | 55M | 极低 |
关键代码逻辑
// atomic 实现节流判断（无锁）
var counter atomic.Int64
func allow() bool {
v := counter.Add(1)
return v <= int64(maxQPS) // 注意：此处隐含窗口重置需外部协调
}
counter.Add(1)是硬件级 CAS 操作，耗时约 10–20 ns；但无法直接实现滑动窗口，需配合定时器或时间分片；而Mutex的Lock()/Unlock()在高争用下易触发操作系统调度，延迟陡增。
适用边界
- ✅
atomic：固定周期、单机 QPS 硬限制、无状态场景 - ⚠️
Mutex：需复合状态（如令牌桶剩余+最后刷新时间）、强顺序一致性要求
2.2 基于令牌桶算法的golang/redis-rate-limiter实战封装与压测对比
封装核心结构
使用 github.com/bsm/redislock + 自研令牌桶逻辑，将 rate.Limit 与 Redis Lua 脚本原子扣减解耦：
func (r *RedisLimiter) Allow(ctx context.Context, key string, limit rate.Limit, burst int) (bool, error) {
script := redis.NewScript(`
local tokens = tonumber(redis.call('GET', KEYS[1])) or 0
local now = tonumber(ARGV[1])
local rate = tonumber(ARGV[2])
local burst = tonumber(ARGV[3])
local lastTime = tonumber(redis.call('GET', KEYS[2])) or 0
local delta = math.max(0, now - lastTime)
local newTokens = math.min(burst, tokens + delta * rate)
if newTokens >= 1 then
redis.call('SET', KEYS[1], newTokens - 1, 'EX', 60)
redis.call('SET', KEYS[2], now, 'EX', 60)
return 1
else
return 0
end
`)
// 参数：KEYS[1]=token_key, KEYS[2]=time_key；ARGV[1]=now, ARGV[2]=rate, ARGV[3]=burst
// 逻辑：按时间衰减补发令牌，原子判断+扣减，避免竞态
return script.Run(ctx, r.client, []string{key + ":tokens", key + ":last"}, time.Now().Unix(), limit, burst).Bool()
}压测关键指标（500并发，10s）
| 方案 | QPS | 99%延迟 | 误判率 |
|---|---|---|---|
| 内存令牌桶（goroutine） | 12,480 | 1.2ms | 0% |
| Redis Lua 封装版 | 8,910 | 8.7ms |
流程示意
graph TD
A[请求到达] --> B{获取当前时间戳}
B --> C[执行Lua脚本]
C --> D[计算可消耗令牌数]
D --> E{≥1?}
E -->|是| F[扣减并更新状态]
E -->|否| G[拒绝请求]
F --> H[返回允许]
G --> I[返回429]2.3 滑动窗口计数器在高并发API网关中的Go实现与内存优化实践
滑动窗口计数器通过时间分片+权重叠加，兼顾精度与性能，是API网关限流的主流方案。
核心数据结构设计
采用 sync.Map 存储每秒桶（map[int64]int64），避免全局锁；窗口大小设为 60s，精度 1s，支持毫秒级时间戳对齐。
Go 实现关键片段
type SlidingWindow struct {
buckets sync.Map // key: timestamp (sec), value: count
window int64 // seconds
}
func (sw *SlidingWindow) Inc(key string, now time.Time) int64 {
sec := now.Unix()
sw.buckets.Store(sec, sw.getBucket(sec)+1)
return sw.sumInRange(sec-sw.window+1, sec)
}
func (sw *SlidingWindow) getBucket(ts int64) int64 {
if v, ok := sw.buckets.Load(ts); ok {
return v.(int64)
}
return 0
}逻辑分析：
Inc原子更新当前秒桶，并计算[now−window+1, now]区间内所有桶之和。getBucket避免零值写入，减少内存抖动；sync.Map适配读多写少场景，实测 QPS 提升 3.2×。
内存优化策略
- 桶自动清理：后台 goroutine 定期驱逐
now−window−5s以外的过期键 - 整数复用：计数器统一使用
int64，避免 interface{} 装箱开销
| 优化项 | 内存节省 | GC 压力降低 |
|---|---|---|
| 桶懒加载 | ~40% | 中 |
| 过期键定时清理 | ~65% | 高 |
| 原生整型存储 | ~15% | 低 |
2.4 自适应限流（如Sentinel Go版）动态阈值决策逻辑与熔断联动验证
动态阈值计算核心逻辑
Sentinel Go 采用滑动窗口 + 指标采样 + 指数加权移动平均（EWMA）实时估算系统负载能力：
// 基于最近10s QPS与响应时间的自适应阈值更新
func updateAdaptiveThreshold(qps, avgRt float64) float64 {
// 公式：threshold = base * (1 - rtNorm) * qpsNorm，rtNorm ∈ [0,1]
rtNorm := math.Min(avgRt/500.0, 1.0) // 响应时间归一化（500ms为饱和点）
qpsNorm := math.Max(qps/100.0, 0.3) // QPS归一化（基准100 QPS）
return 200 * (1 - rtNorm) * qpsNorm // 初始基线200，动态收缩
}该函数每5秒触发一次，输入为当前窗口统计的 qps 与 avgRt；rtNorm 越高表示延迟越重，qpsNorm 反映吞吐压力，二者共同抑制阈值膨胀。
熔断联动触发条件
| 条件项 | 触发阈值 | 作用 |
|---|---|---|
| 错误率 | ≥ 50%（持续30s） | 快速失败，避免雪崩 |
| 响应超时率 | ≥ 80% | 防止慢调用堆积线程池 |
| 自适应阈值跌破 | ≤ 当前QPS × 0.7 | 主动降级，触发半开探测 |
决策流程图
graph TD
A[采集QPS/RT/错误率] --> B{是否满足熔断条件？}
B -- 是 --> C[开启熔断，拒绝新请求]
B -- 否 --> D{自适应阈值 < 当前QPS×0.7？}
D -- 是 --> E[触发限流+上报熔断预备信号]
D -- 否 --> F[维持当前阈值]2.5 基于context.WithTimeout+goroutine池的请求级限流拦截链路设计
在高并发网关场景中，单请求需同时调用多个下游服务，易因长尾延迟拖垮整体吞吐。传统全局 goroutine 池无法感知请求生命周期，存在资源滞留风险。
核心设计思想
- 每个 HTTP 请求绑定独立
context.WithTimeout - 在 context 取消时自动回收该请求关联的所有协程资源
- 复用轻量级 worker pool（非 runtime.GOMAXPROCS 级别）
关键代码片段
func handleRequest(ctx context.Context, req *http.Request) {
// 为本次请求创建带超时的子 context
reqCtx, cancel := context.WithTimeout(ctx, 800*time.Millisecond)
defer cancel() // 确保退出时释放信号
// 提交至共享 goroutine 池，但携带 reqCtx 实现请求级取消
pool.Submit(func() {
select {
case <-doWork(reqCtx): // 工作函数内部监听 reqCtx.Done()
case <-reqCtx.Done():
log.Warn("request cancelled or timeout")
}
})
}逻辑分析：
context.WithTimeout生成可取消的请求上下文，pool.Submit接收闭包并由 worker 执行；doWork内部需持续检查reqCtx.Err()，确保 I/O 或计算任务能及时响应取消。defer cancel()防止 goroutine 泄漏。
| 维度 | 传统池方案 | 本方案 |
|---|---|---|
| 超时控制粒度 | 全局/无 | 请求级、毫秒级精准控制 |
| 资源回收时机 | GC 或手动清理 | context.Cancel 后立即释放 |
graph TD
A[HTTP Request] --> B[context.WithTimeout]
B --> C[Goroutine Pool Submit]
C --> D{Worker 执行}
D --> E[doWork with reqCtx]
E --> F[select on reqCtx.Done]
F -->|timeout/cancel| G[Clean up & exit]第三章：Prometheus+Grafana限流可观测性体系构建
3.1 Prometheus自定义指标埋点规范：从http_request_total到rate_limited_requests_total
基础计数器的局限性
http_request_total 是标准 HTTP 请求总量指标，但无法区分请求是否被限流拦截——它统计所有进入 handler 的请求，而限流逻辑常在 middleware 或网关层提前拒绝。
埋点时机决定语义准确性
限流指标必须在决策点埋点，而非响应后：
// ✅ 正确：在限流器判定后立即打点
if limiter.Allow() {
http_request_total.WithLabelValues("200").Inc()
} else {
rate_limited_requests_total.Inc() // 无标签，聚焦核心事件
}rate_limited_requests_total 应为无标签 Counter，避免因标签爆炸稀释可观测性；Inc() 调用必须原子、幂等，且不依赖后续处理路径。
标签设计黄金法则
| 维度 | 推荐值 | 禁忌 |
|---|---|---|
reason |
"burst_exceeded" |
动态错误码（如 "429"） |
policy |
"per_ip_global" |
用户ID等高基数字段 |
指标演进路径
graph TD
A[http_request_total] --> B[添加middleware标签]
B --> C[拆分rate_limited_requests_total]
C --> D[关联trace_id实现根因下钻]3.2 Grafana看板模板核心Panel解析：QPS、拒绝率、P99延迟热力图与限流触发溯源
QPS与拒绝率双轴联动Panel
使用Prometheus指标rate(http_requests_total[1m])计算每秒请求数，rate(http_requests_total{status=~"429|503"}[1m])提取限流/服务不可用请求。
# QPS（蓝色线）
rate(http_requests_total[1m])
# 拒绝率（红色填充区域，归一化为百分比）
100 * rate(http_requests_total{status=~"429|503"}[1m])
/ rate(http_requests_total[1m])rate()自动处理计数器重置；[1m]窗口平衡灵敏度与噪声抑制；分母非零校验由Grafana面板“Null value”设为“Connected”隐式保障。
P99延迟热力图设计
基于直方图指标http_request_duration_seconds_bucket，通过histogram_quantile(0.99, ...)动态聚合，X轴为时间，Y轴为延迟区间（0.01s–10s对数刻度），颜色深浅映射请求密度。
限流触发溯源逻辑
当拒绝率突增时，联动查询标签 reason="rate_limit_exceeded" 的日志流，并关联trace_id字段跳转至Jaeger。
| 字段 | 用途 | 示例值 |
|---|---|---|
route |
匹配限流规则路径 | /api/v1/order |
quota_used_ratio |
当前配额占用率 | 0.98 |
burst_remaining |
突发窗口余量 | 2 |
graph TD
A[HTTP入口] --> B{限流中间件}
B -->|允许| C[业务处理]
B -->|拒绝| D[打标reason+route+quota_used_ratio]
D --> E[Prometheus采集]
E --> F[Grafana热力图联动高亮]3.3 基于Alertmanager的限流异常告警策略：连续超阈值、突增拒绝率、下游依赖雪崩前兆识别
核心告警维度设计
- 连续超阈值：
rate(limit_rejections_total[5m]) > 0.1持续3个评估周期（90s） - 突增拒绝率：同比前10分钟增幅 >200%，触发
abs((rate(...) - offset rate(...)) / offset rate(...)) > 2 - 雪崩前兆：上游服务A的
http_request_duration_seconds_bucket{le="0.2"}达标率骤降，同时下游B的up == 0或probe_success == 0
关键Prometheus告警规则示例
- alert: HighRateLimitRejection
expr: |
count_over_time(
(rate(limit_rejections_total[2m]) > 0.08)[10m:1m]
) >= 5 # 连续5次采样超阈值（即5分钟内每分钟均超标）
for: 2m
labels:
severity: warning
category: rate-limit
annotations:
summary: "限流拒绝率持续偏高（{{ $value }}）"逻辑说明：
count_over_time(...[10m:1m])在10分钟窗口内按1分钟步长重采样，统计满足条件的样本数；>=5确保非瞬时抖动。for: 2m避免Alertmanager重复发送，与评估周期对齐。
雪崩链路识别流程
graph TD
A[上游服务QPS突增] --> B{限流器拒绝率 >15%}
B -->|持续2min| C[下游依赖P99延迟↑300ms]
C -->|且probe_success==0| D[触发雪崩前兆告警]| 指标维度 | 阈值策略 | 告警抑制关系 |
|---|---|---|
| 连续超阈值 | 5次/10分钟 | 抑制单点瞬时抖动 |
| 突增拒绝率 | 同比增幅 >200% | 仅当QPS基线 >100 |
| 下游雪崩前兆 | P99延迟↑+探活失败 | 联动熔断器状态指标 |
第四章：大促前必须执行的3项限流压测验证全流程
4.1 静态阈值压测：JMeter模拟阶梯流量验证RateLimiter硬限流生效精度与误差容忍度
测试目标
验证 RateLimiter.create(100.0) 在 100 QPS 静态阈值下，面对阶梯式并发（50→100→150→200 TPS）的实际拦截精度与响应延迟波动边界。
JMeter线程组配置（CSV数据驱动）
<!-- JMeter ThreadGroup 阶梯递增逻辑（通过 JSR223 Timer 控制发压节奏） -->
<elementProp name="ThreadGroup.mainController" ...>
<stringProp name="loops">1</stringProp>
<stringProp name="num_threads">200</stringProp> <!-- 模拟峰值200并发 -->
</elementProp>逻辑说明：num_threads=200 结合 Constant Throughput Timer 设置目标吞吐量（如150/sec），实现精准阶梯加压；loops=1 确保单轮压测避免状态累积。
响应结果误差分析（10秒滑动窗口统计）
| 阶梯目标TPS | 实际通过QPS | 拦截率误差 | P95延迟（ms） |
|---|---|---|---|
| 100 | 98.3 | ±1.7% | 12.4 |
| 150 | 100.1 | +0.1% | 48.6 |
限流生效时序验证（Mermaid）
graph TD
A[请求抵达] --> B{RateLimiter.tryAcquire()?}
B -->|true| C[执行业务逻辑]
B -->|false| D[返回429 Too Many Requests]
C --> E[记录metric: passed_count]
D --> F[记录metric: rejected_count]4.2 动态阈值压测：Chaos Mesh注入延迟与错误，验证自适应限流对下游抖动的收敛响应时间
场景构建：Chaos Mesh 延迟注入
使用 Chaos Mesh 的 NetworkChaos 模拟下游服务 RT 抖动：
apiVersion: chaos-mesh.org/v1alpha1
kind: NetworkChaos
metadata:
name: downstream-latency
spec:
action: delay
delay:
latency: "100ms" # 基线延迟
correlation: "20" # 抖动相关性（0–100）
mode: one
selector:
namespaces: ["prod"]
labels:
app: payment-service该配置在单个 payment-service Pod 上注入带相关性的 100ms 网络延迟，模拟真实链路波动；correlation 参数控制延迟突增的持续性，避免瞬时尖刺，更贴近机房级抖动特征。
自适应限流响应观测维度
| 指标 | 采集方式 | 收敛判定阈值 |
|---|---|---|
| P95 响应时间 | Prometheus + SLI | ≤120ms |
| 限流触发频率 | Sentinel 日志 | 波动 |
| QPS 自动下调幅度 | APISIX metrics | ≥30%（30s内） |
收敛流程示意
graph TD
A[下游RT突增] --> B{自适应控制器采样}
B --> C[动态计算QPS阈值]
C --> D[下发新限流规则至Envoy]
D --> E[10s内P95回落至115ms]
E --> F[收敛完成]4.3 混沌故障压测：强制关闭Redis限流存储后，本地fallback策略的降级完整性与日志可追溯性
数据同步机制
当 Redis 实例被 Chaos Mesh 强制 Kill 后，限流器自动切换至 Caffeine 本地缓存 + 内存计数器 fallback 模式。关键保障在于：
- 降级瞬间不丢失当前窗口计数（通过
AtomicLong快照） - 所有 fallback 决策写入结构化日志（含 traceId、key、decision、source）
日志可追溯性设计
log.warn("RATELIMIT_FALLBACK_APPLIED",
MarkerFactory.getMarker("FALLBACK"),
"key={}, window={}, count={}, source=redis_unavailable",
key, windowMs, currentCount.get(), traceId); // traceId 确保全链路关联此日志使用 SLF4J Marker 分类，便于 ELK 中按
FALLBACK聚合；source=redis_unavailable显式标注故障根因，避免误判为业务逻辑降级。
降级完整性验证路径
graph TD
A[Redis connect timeout] --> B{Fallback switch}
B --> C[加载最近快照到 Caffeine]
B --> D[启用 AtomicLong 计数器]
C & D --> E[统一 LogEntry 输出]
E --> F[ELK 中 traceId 关联原始请求]| 验证维度 | 通过标准 |
|---|---|
| 计数连续性 | fallback前后窗口计数偏差 ≤1 |
| 日志覆盖率 | 100% fallback 事件带 traceId |
4.4 全链路染色压测：通过OpenTelemetry TraceID透传，定位限流拦截点与上游重试放大效应
在微服务架构中，限流策略常导致隐性失败与重试雪崩。全链路染色压测借助 OpenTelemetry 的 TraceID 跨进程透传能力，将压测流量打上唯一标识（如 x-benchmark-id: bench-20241107-001），实现端到端追踪。
核心透传机制
需在网关、RPC 框架、消息中间件中统一注入与提取上下文：
// Spring Cloud Gateway 过滤器中透传 TraceID 与压测标
public class TracePropagationFilter implements GlobalFilter {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
String traceId = Span.current().getSpanContext().getTraceId(); // OTel 标准 TraceID
ServerHttpRequest request = exchange.getRequest()
.mutate()
.header("X-Trace-ID", traceId)
.header("X-Benchmark-Flag", "true") // 显式标记压测流量
.build();
return chain.filter(exchange.mutate().request(request).build());
}
}逻辑分析：该过滤器确保每个压测请求携带标准
TraceID及自定义压测标识，使下游服务可识别并启用影子库、隔离限流等策略；X-Benchmark-Flag是业务侧判断是否走压测通道的关键开关。
限流拦截定位流程
graph TD
A[压测请求] --> B[API 网关：记录 TraceID + BenchmarkFlag]
B --> C[Service A：检查限流规则]
C -->|触发限流| D[返回 429 + X-Retry-After]
D --> E[上游客户端：自动重试 ×3]
E --> F[TraceID 聚合分析：发现同一 TraceID 出现 4 次调用]常见重试放大模式对比
| 场景 | 正常流量 QPS | 压测流量 QPS | TraceID 复用次数 | 风险等级 |
|---|---|---|---|---|
| 无重试 | 100 | 100 | 1 | 低 |
| 客户端指数退避重试 | 100 | 340 | 4 | 高 |
| 服务端异步补偿重试 | 100 | 200 | 2 | 中 |
第五章：限流golang
在高并发微服务场景中，Go 语言凭借其轻量级 Goroutine 和原生并发模型成为限流组件的理想载体。本章聚焦于在真实生产环境中落地限流策略的 Go 实现细节，涵盖令牌桶、漏桶及分布式场景下的协同设计。
本地内存令牌桶实现
使用 golang.org/x/time/rate 包可快速构建高性能单机限流器。以下代码为 HTTP 中间件形式的限流封装，支持动态配置每秒请求数（QPS）与突发容量：
func RateLimitMiddleware(limiter *rate.Limiter) gin.HandlerFunc {
return func(c *gin.Context) {
if !limiter.Allow() {
c.JSON(http.StatusTooManyRequests, gin.H{"error": "rate limit exceeded"})
c.Abort()
return
}
c.Next()
}
}
// 初始化：10 QPS，允许最多5个请求突发
limiter := rate.NewLimiter(10, 5)该实现无锁、零分配，在压测中可稳定支撑 30K+ RPS，CPU 占用低于 3%（Intel Xeon Platinum 8360Y，Go 1.22）。
基于 Redis 的分布式滑动窗口限流
当服务部署于多实例集群时，需借助共享存储保障限流一致性。以下采用 Redis 的 ZSET 实现滑动窗口（时间窗口为60秒，最大请求数1000）：
| 步骤 | Redis 命令 | 说明 |
|---|---|---|
| 1 | ZREMRANGEBYSCORE key -inf (now-60000) |
清理过期时间戳 |
| 2 | ZCARD key |
获取当前窗口内请求数 |
| 3 | ZADD key now_ms request_id |
插入新请求并设置分数为毫秒时间戳 |
| 4 | EXPIRE key 61 |
设置键过期防止内存泄漏 |
Go 客户端调用示例（使用 github.com/redis/go-redis/v9）：
func SlidingWindowCheck(ctx context.Context, rdb *redis.Client, key string, windowSec int64, maxReq int64) (bool, error) {
now := time.Now().UnixMilli()
windowStart := now - windowSec*1000
pipe := rdb.TxPipeline()
pipe.ZRemRangeByScore(ctx, key, "-inf", fmt.Sprintf("(%.0f", float64(windowStart)))
pipe.ZCard(ctx, key)
pipe.ZAdd(ctx, key, &redis.Z{Score: float64(now), Member: uuid.New().String()})
pipe.Expire(ctx, key, time.Duration(windowSec+1)*time.Second)
_, err := pipe.Exec(ctx)
if err != nil {
return false, err
}
card, err := pipe.ZCard(ctx, key).Result()
if err != nil {
return false, err
}
return card <= maxReq, nil
}限流策略选型对比
| 策略类型 | 适用场景 | 时序特性 | 实现复杂度 | 典型延迟开销 |
|---|---|---|---|---|
| 令牌桶（内存） | API 网关入口、单体服务 | 平滑突发容忍 | ★☆☆ | |
| 滑动窗口（Redis） | 用户维度频控、登录保护 | 精确窗口统计 | ★★★ | 0.8–2.3ms（P99） |
| 漏桶（Channel + ticker） | 日志采集、消息推送下游缓冲 | 强制匀速输出 | ★★☆ |
生产环境关键配置实践
某电商大促期间，订单服务在 Kubernetes 集群中部署 12 个 Pod，通过 Envoy Sidecar 注入全局限流策略后仍出现 Redis 连接打满问题。根因分析发现滑动窗口未启用连接池复用与 pipeline 批处理。优化后将 redis.Options.PoolSize 从默认10提升至200，并改用 TxPipeline 替代多次 ZADD，Redis QPS 下降 67%，平均响应时间从 1.9ms 降至 0.7ms。
多维度组合限流架构图
flowchart LR
A[客户端请求] --> B[Envoy 全局速率限制]
B --> C{是否命中用户ID限流？}
C -->|是| D[Redis 滑动窗口校验]
C -->|否| E[服务进程内令牌桶]
D --> F[通过/拒绝]
E --> F
F --> G[业务Handler]
G --> H[异步上报限流日志至Loki]