Go 分布式限流：副本数翻倍之后，额度归谁管

limiter := rate.NewLimiter(rate.Limit(125), 250) // 125 QPS，允许 250 的瞬时突发

// 1) Allow：非阻塞。拿不到令牌立刻返回 false，适合在线接口快速失败
if !limiter.Allow() {
    // 返回 429
}

// 2) Wait：阻塞到拿到令牌或 ctx 结束。适合能排队的后台任务；
//    在线接口用它要小心——排队本身就在堆延迟
if err := limiter.Wait(ctx); err != nil {
    // ctx 超时或取消
}

// 3) Reserve：不消费令牌，先问「最早多久以后能拿到」
r := limiter.Reserve()
if !r.OK() {
    // 申请数量超过 burst 时永远拿不到；单请求场景不会走到这
}
// time.Sleep(r.Delay()) 之前，可以把 Delay() 换算成 Retry-After 头还给客户端

-- KEYS[1] 限流 key，如 rl:tenant:42:write
-- ARGV[1] 窗口内限额
-- ARGV[2] 当前毫秒时间戳（调用方传入，避免多副本叠加 Redis 服务器时钟差）
-- ARGV[3] 窗口长度（毫秒）
-- ARGV[4] 本次请求的唯一 ID
redis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', ARGV[2] - ARGV[3])

if redis.call('ZCARD', KEYS[1]) < tonumber(ARGV[1]) then
    redis.call('ZADD', KEYS[1], ARGV[2], ARGV[4])
    redis.call('PEXPIRE', KEYS[1], ARGV[3]) -- 每次刷新 TTL，无流量后 key 自动过期
    return 1
end
return 0

package ratelimit

import (
    "context"
    "crypto/rand"
    "encoding/hex"
    "time"

    "github.com/redis/go-redis/v9"
)

var slidingWindow = redis.NewScript(`
redis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', ARGV[2] - ARGV[3])
if redis.call('ZCARD', KEYS[1]) < tonumber(ARGV[1]) then
    redis.call('ZADD', KEYS[1], ARGV[2], ARGV[4])
    redis.call('PEXPIRE', KEYS[1], ARGV[3])
    return 1
end
return 0
`)

type Limiter struct {
    rdb    *redis.Client
    limit  int64
    window time.Duration
}

func (l *Limiter) Allow(ctx context.Context, key string) (bool, error) {
    id := make([]byte, 8)
    _, _ = rand.Read(id)

    n, err := slidingWindow.Run(ctx, l.rdb, []string{key},
        l.limit,                 // ARGV[1] 限额
        time.Now().UnixMilli(),  // ARGV[2] 当前毫秒
        l.window.Milliseconds(), // ARGV[3] 窗口毫秒
        hex.EncodeToString(id),  // ARGV[4] 唯一 member
    ).Int()
    if err != nil {
        return false, err // 注意：这里上报的是「限流器不可用」，不是「超限」，两者语义完全不同
    }
    return n == 1, nil
}

-- KEYS[1] 计数 key；ARGV[1] 本次申领量；ARGV[2] 窗口限额；ARGV[3] TTL 毫秒
local used = redis.call('INCRBY', KEYS[1], ARGV[1])
if used > tonumber(ARGV[2]) then
    redis.call('DECRBY', KEYS[1], ARGV[1]) -- 超领的部分退回去
    redis.call('PEXPIRE', KEYS[1], ARGV[3])
    return math.max(0, tonumber(ARGV[2]) - (used - tonumber(ARGV[1]))) -- 只给剩余额度
end
redis.call('PEXPIRE', KEYS[1], ARGV[3])
return tonumber(ARGV[1]) -- 足额领到

type CreditPool struct {
    credits atomic.Int64
    batch   int64 // 全局额度 × 领取周期 × 少量裕量，例如 5000 × 0.1s × 1.2
    lease   func(ctx context.Context, batch int64) (int64, error)
}

func (p *CreditPool) Allow() bool {
    for {
        left := p.credits.Load()
        if left <= 0 {
            return false // 本地配额耗尽：语义是拒绝，不是等待
        }
        if p.credits.CompareAndSwap(left, left-1) {
            return true
        }
    }
}

func (p *CreditPool) StartRefill(ctx context.Context, every time.Duration) {
    ticker := time.NewTicker(every)
    defer ticker.Stop()
    for {
        select {
        case <-ctx.Done():
            return
        case <-ticker.C:
            granted, err := p.lease(ctx, p.batch)
            if err != nil {
                continue // 领取失败不补配额；连续失败要靠指标暴露，不能默默放行
            }
            p.credits.Add(granted)
        }
    }
}

type FailPolicy int

const (
    FailOpen FailPolicy = iota // 放行，退回本地粗粒度限流：推荐流、搜索
    FailClosed                 // 拒绝：支付、扣库存这类超限有直接资损的
)

func (g *Guard) Allow(ctx context.Context, key string) bool {
    ok, err := g.redis.Allow(ctx, key)
    if err == nil {
        return ok
    }
    g.redisErrors.Add(1) // 限流器自身的错误率是独立指标，别和业务错误率混在一起

    if g.policy == FailOpen {
        return g.local.Allow() // 本地兜底额度按「全局 ÷ 预期副本数」粗配，宁粗勿无
    }
    return false
}

func writeLimited(w http.ResponseWriter, retryAfter time.Duration, limit, remaining int64, resetAt time.Time) {
    // Retry-After 是标准头，单位秒；X-RateLimit-* 是业界事实约定（标准化草案演进中）
    w.Header().Set("Retry-After", strconv.Itoa(int(retryAfter.Seconds()+0.5)))
    w.Header().Set("X-RateLimit-Limit", strconv.FormatInt(limit, 10))
    w.Header().Set("X-RateLimit-Remaining", strconv.FormatInt(remaining, 10))
    w.Header().Set("X-RateLimit-Reset", strconv.FormatInt(resetAt.Unix(), 10))
    w.WriteHeader(http.StatusTooManyRequests)
    _, _ = w.Write([]byte(`{"error":"rate_limited"}`))
}