如何在Golang中实现微服务限流策略_Golang微服务限流策略实现方法汇总

type CounterLimiter struct {
    count    int
    limit    int
    window   time.Duration
    startTime time.Time
}

func NewCounterLimiter(limit int, window time.Duration) *CounterLimiter {
    return &CounterLimiter{
        limit:    limit,
        window:   window,
        startTime: time.Now(),
    }
}

func (c *CounterLimiter) Allow() bool {
    now := time.Now()
    if now.Sub(c.startTime) > c.window {
        c.count = 0
        c.startTime = now
    }
    if c.count >= c.limit {
        return false
    }
    c.count++
    return true
}

type SlidingWindowLimiter struct {
    window      time.Duration
    maxRequests int
    requests    []time.Time
    mu          sync.Mutex
}

func (s *SlidingWindowLimiter) Allow() bool {
    s.mu.Lock()
    defer s.mu.Unlock()

    now := time.Now()
    // 移除过期请求
    for len(s.requests) > 0 && now.Sub(s.requests[0]) >= s.window {
        s.requests = s.requests[1:]
    }

    if len(s.requests) < s.maxRequests {
        s.requests = append(s.requests, now)
        return true
    }
    return false
}

import "golang.org/x/time/rate"

limiter := rate.NewLimiter(rate.Limit(100), 200) // 每秒100个令牌，初始容量200

func handler(w http.ResponseWriter, r *http.Request) {
    if !limiter.Allow() {
        http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
        return
    }
    // 处理请求
}

type LeakyBucket struct {
    capacity  int       // 桶容量
    water     int       // 当前水量
    rate      int       // 漏水速率（单位/秒）
    lastLeak  time.Time // 上次漏水时间
    mu        sync.Mutex
}

func (b *LeakyBucket) Allow() bool {
    b.mu.Lock()
    defer b.mu.Unlock()

    now := time.Now()
    // 计算应漏掉的水量
    elapsed := now.Sub(b.lastLeak).Seconds()
    leak := int(elapsed) * b.rate
    if leak > 0 {
        b.water = max(0, b.water-leak)
        b.lastLeak = now
    }

    if b.water < b.capacity {
        b.water++
        return true
    }
    return false
}

-- KEYS[1]: key
-- ARGV[1]: window size in seconds
-- ARGV[2]: max requests
local key = KEYS[1]
local window = tonumber(ARGV[1])
local max = tonumber(ARGV[2])
local now = redis.call('TIME')[1]

-- 移除过期请求
redis.call('ZREMRANGEBYSCORE', key, 0, now - window)

-- 统计当前请求数
local current = redis.call('ZCARD', key)
if current < max then
    redis.call('ZADD', key, now, now .. '-' .. math.random())
    redis.call('EXPIRE', key, window)
    return 1
else
    return 0
end

script := redis.NewScript(luaScript)
result, err := script.Run(ctx, client, []string{"limit:user:123"}, window, max).Int()
return result == 1