Golang API限流实现 令牌桶算法应用

答案：Go语言中API限流推荐使用golang.org/x/time/rate包实现令牌桶算法，它允许突发流量通过并控制平均速率，相比漏桶更灵活；可通过全局或基于客户端的限流中间件实现，分布式环境下需借助Redis原子操作（如Lua脚本）解决状态共享问题。

API限流在Go语言里，用令牌桶算法来实现，是个挺实用的选择。它能有效地保护你的服务不被突发流量冲垮，同时又允许一定程度的“爆发”，让用户体验不至于太差。核心思想就是给每个请求发一个“令牌”，没有令牌就得等着或者被拒绝，但这个令牌桶本身会以一个固定速率不断补充令牌，并且有个最大容量，保证了既能控制平均速率，又能应对短时间的流量高峰。

解决方案

在Golang里实现API限流，最直接也最推荐的方式是使用标准库扩展包

golang.org/x/time/rate

它的核心是

rate.Limiter

Limiter

1. r rate.Limit

   ：令牌的生成速率，通常是每秒多少个令牌（e.g.,

   rate.Every(time.Second / 10)

   表示每秒10个令牌，或者

   rate.Limit(10)

   也是每秒10个）。

2. b int

   ：令牌桶的容量，也就是允许的最大突发请求数。

比如，

limiter := rate.NewLimiter(rate.Every(time.Second/10), 100)

立即学习“go语言免费学习笔记（深入）”；

使用时，你可以选择两种模式：

• limiter.Allow()

  ：非阻塞模式。它会立即返回一个布尔值，告诉你当前请求是否被允许。如果桶里有令牌，就消耗一个并返回

  true

  ；否则返回

  false

  。

• limiter.Wait(ctx context.Context)

  ：阻塞模式。它会阻塞当前请求，直到令牌桶中有足够的令牌可用。你可以传入一个

  context

  来控制等待超时。

在HTTP服务中，通常会把它做成一个中间件。

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"

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

// 创建一个全局限流器，每秒允许10个请求，桶容量为20
var globalLimiter = rate.NewLimiter(rate.Every(time.Second/10), 20)

func rateLimitMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 尝试获取令牌，如果无法获取，则返回429
        if !globalLimiter.Allow() {
            http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
            return
        }
        next.ServeHTTP(w, r)
    })
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, you are not rate limited!")
}

func main() {
    http.Handle("/hello", rateLimitMiddleware(http.HandlerFunc(helloHandler)))
    log.Fatal(http.ListenAndServe(":8080", nil))
}

这个例子展示了一个最基本的全局限流器。实际应用中，你可能需要更复杂的逻辑，比如针对不同用户或不同API路径进行限流。

为什么选择令牌桶算法，它与漏桶算法有何不同？

选择令牌桶算法，我个人觉得它在API限流场景下更“人性化”一些。你看，漏桶算法（Leaky Bucket）就像一个固定出水速率的水桶，无论你往里倒多少水，它都以恒定速度往外漏。这意味着它能平滑请求流量，确保后端处理能力稳定。但问题是，如果突然来了个流量高峰，漏桶会直接把多余的请求溢出（拒绝），或者排队等待，但这个队列可能很长，导致延迟很高。

而令牌桶就不一样了。它更像是“允许爆发”的设计。令牌桶里平时就存着一些令牌，当请求来的时候，只要桶里有令牌，就能立即通过，即使是短时间内的连续请求，只要没超过桶的容量，都能顺利通过。这对于用户体验来说非常重要，比如用户在短时间内进行多次点击操作，只要不是恶意的，我们通常希望这些请求都能被处理。只有当桶里的令牌用完了，新的请求才会被限制。

简单来说：

• 漏桶算法：强制输出速率平滑，无法处理突发流量，或者说，它把突发流量“平滑”成了固定速率。适合后端处理能力固定的场景。
• 令牌桶算法：允许短时间内的突发流量，但长期平均速率受控。更适合Web API这种有一定弹性，且需要兼顾用户体验的场景。

所以，我通常会觉得，对于大部分API服务，令牌桶在灵活性和实用性上更胜一筹。

在Golang中如何优雅地集成令牌桶限流？

在Go里优雅地集成令牌桶限流，不仅仅是使用

rate.NewLimiter

蝉妈妈AI

电商人专属的AI营销助手

下载

这通常意味着你需要维护一个

map

*rate.Limiter

package main

import (
    "fmt"
    "log"
    "net/http"
    "sync"
    "time"

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

// clientLimiterStore 存储每个客户端的限流器
type clientLimiterStore struct {
    limiters map[string]*rate.Limiter
    mu       sync.Mutex
    // 默认限流参数
    r rate.Limit
    b int
}

func newClientLimiterStore(r rate.Limit, b int) *clientLimiterStore {
    return &clientLimiterStore{
        limiters: make(map[string]*rate.Limiter),
        r:        r,
        b:        b,
    }
}

// GetLimiter 为指定客户端获取或创建一个限流器
func (s *clientLimiterStore) GetLimiter(clientID string) *rate.Limiter {
    s.mu.Lock()
    defer s.mu.Unlock()

    limiter, exists := s.limiters[clientID]
    if !exists {
        limiter = rate.NewLimiter(s.r, s.b)
        s.limiters[clientID] = limiter
    }
    return limiter
}

// 清理不活跃的限流器，防止内存泄漏
func (s *clientLimiterStore) CleanupOldLimiters() {
    ticker := time.NewTicker(5 * time.Minute) // 每5分钟清理一次
    defer ticker.Stop()

    for range ticker.C {
        s.mu.Lock()
        for clientID, limiter := range s.limiters {
            // 这是一个简化的清理逻辑，实际可能需要更复杂的判断
            // 比如：如果某个limiter在N分钟内没有被访问过，则删除
            // 这里只是演示，实际生产不建议直接删除，需要记录上次访问时间
            _ = limiter // 占位符，避免unused变量警告
            // 假设我们有一个机制来判断哪些limiter不再需要
            // delete(s.limiters, clientID)
        }
        s.mu.Unlock()
        log.Println("Cleaned up old limiters (simplified logic)")
    }
}

// 初始化客户端限流存储，每秒5个请求，桶容量10
var clientLimiters = newClientLimiterStore(rate.Every(time.Second/5), 10)

func init() {
    go clientLimiters.CleanupOldLimiters() // 启动后台清理goroutine
}

func perClientRateLimitMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 实际应用中，clientID可以是用户ID、API Key或客户端IP
        // 这里简化为从查询参数获取，实际应从认证信息或请求头获取
        clientID := r.URL.Query().Get("client_id")
        if clientID == "" {
            clientID = r.RemoteAddr // 如果没有client_id，则使用IP作为标识
        }

        limiter := clientLimiters.GetLimiter(clientID)

        // 阻塞等待令牌，最多等待1秒
        ctx, cancel := context.WithTimeout(r.Context(), time.Second)
        defer cancel()

        if err := limiter.Wait(ctx); err != nil {
            // 如果等待超时或者context被取消
            http.Error(w, "Too Many Requests or Request Timeout", http.StatusTooManyRequests)
            return
        }
        next.ServeHTTP(w, r)
    })
}

func main() {
    http.Handle("/api/data", perClientRateLimitMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Data for client %s, not rate limited!", r.URL.Query().Get("client_id"))
    })))
    log.Fatal(http.ListenAndServe(":8081", nil))
}

这种方式允许你为每个独立的客户端提供不同的限流策略，或者至少是独立的计数。但要注意，这种内存中的

map

map

令牌桶限流在分布式环境下的挑战与应对策略

当你的Go服务不是单实例运行，而是部署在多台机器上，或者通过负载均衡器分发流量时，前面提到的内存中的

rate.Limiter

这里面的挑战主要是：

1. 状态共享：如何让所有服务实例共享同一个令牌桶的状态？
2. 原子性操作：令牌的扣减和补充必须是原子性的，避免并发问题。
3. 性能：分布式限流不能成为服务的瓶颈。

应对策略通常是引入一个中心化的存储来管理令牌桶的状态。Redis是这里面的“明星选手”，因为它支持原子操作和高性能。

使用Redis实现分布式令牌桶的基本思路：

1. 存储结构：为每个需要限流的“桶”（比如，每个用户ID或API路径）在Redis中存储两个关键信息：

   • last_refill_time

     ：上次令牌桶补充令牌的时间戳。

   • current_tokens

     ：当前桶中剩余的令牌数量。

2. 请求处理逻辑：

   • 当一个请求到来时，服务实例向Redis发起请求。
   • Redis接收请求后，首先计算从

     last_refill_time

     到当前时间，应该补充了多少令牌。
   • 将计算出的令牌数加到

     current_tokens

     上，但不能超过桶的最大容量。
   • 检查

     current_tokens

     是否足够扣减一个令牌。
   • 如果足够，扣减一个令牌，更新

     current_tokens

     和

     last_refill_time

     ，并返回允许。
   • 如果不足，返回拒绝。

3. 原子性：这一系列操作必须是原子性的，以防止并发问题。Redis的Lua脚本是实现原子操作的完美工具。你可以把上述所有逻辑封装在一个Lua脚本里，然后一次性发送给Redis执行。

一个简化的Lua脚本逻辑可能长这样（这只是伪代码，实际需要考虑更多细节，比如key的过期时间）：

-- KEYS[1]: key for last_refill_time
-- KEYS[2]: key for current_tokens
-- ARGV[1]: bucket_capacity
-- ARGV[2]: refill_rate_per_second
-- ARGV[3]: current_timestamp_in_ms
-- ARGV[4]: tokens_to_consume (usually 1)

local last_refill_time = tonumber(redis.call('GET', KEYS[1]) or "0")
local current_tokens = tonumber(redis.call('GET', KEYS[2]) or "0")
local bucket_capacity = tonumber(ARGV[1])
local refill_rate_per_second = tonumber(ARGV[2])
local current_timestamp_in_ms = tonumber(ARGV[3])
local tokens_to_consume = tonumber(ARGV[4])

-- 计算需要补充的令牌
local time_passed_ms = current_timestamp_in_ms - last_refill_time
local tokens_to_add = (time_passed_ms / 1000) * refill_rate_per_second

-- 更新令牌数量，不能超过桶容量
current_tokens = math.min(bucket_capacity, current_tokens + tokens_to_add)

-- 检查是否可以消费令牌
if current_tokens >= tokens_to_consume then
    current_tokens = current_tokens - tokens_to_consume
    redis.call('SET', KEYS[1], current_timestamp_in_ms)
    redis.call('SET', KEYS[2], current_tokens)
    return 1 -- 允许
else
    return 0 -- 拒绝
end

在Go服务中，你就通过Redis客户端执行这个Lua脚本。

分布式限流虽然解决了多实例的问题，但它引入了网络延迟和Redis的可用性依赖。所以，在设计时需要权衡：你的限流需求有多严格？是否值得为了绝对的准确性而引入额外的复杂性和潜在的性能开销？有时候，对于非核心的API，允许一点点“超发”可能是可以接受的，那么简单的内存限流加负载均衡的均匀分发可能就够了。但对于支付、订单等关键API，分布式限流几乎是必选项。