如何用Golang实现并发限流器对比令牌桶与漏桶算法实现

P粉602998670

发布时间：2025-08-16 15:44:02

248人浏览过

来源于php中文网

原创

golang实现并发限流器的方法有三种：1. 基于channel的限流器，通过缓冲channel控制最大并发数，请求到来时发送数据到channel，处理完后接收数据释放位置，若channel满则阻塞等待；2. 基于golang.org/x/time/rate的令牌桶限流器，使用rate包创建令牌桶，设置令牌生成速率和桶容量，通过wait方法阻塞直到获取令牌；3. 基于redis的分布式限流器，利用redis的原子操作如incr命令结合过期时间实现滑动窗口限流。令牌桶允许突发流量但控制总量，漏桶则严格平滑流量，选择算法需考虑业务场景、系统架构与性能要求，同时可通过监控请求通过率、拒绝率和平均响应时间调整限流策略。

如何用Golang实现并发限流器对比令牌桶与漏桶算法实现

Golang实现并发限流器，本质上是为了控制程序在单位时间内处理请求的数量，防止系统过载。令牌桶和漏桶是两种常见的限流算法，它们各有优缺点，选择哪种取决于具体的应用场景。

解决方案

用Golang实现并发限流器，主要有以下几种方法：

基于Channel的限流器： 这是最简单的一种实现方式。创建一个带有缓冲的channel，channel的容量就是允许的最大并发数。每当有请求到来时，就向channel中发送一个数据，请求处理完成后，从channel中接收一个数据。如果channel满了，说明当前并发数已经达到上限，请求就会被阻塞，直到有空闲的channel位置。

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

package main

import (
    "fmt"
    "sync"
    "time"
)

type RateLimiter struct {
    ch chan struct{}
}

func NewRateLimiter(capacity int) *RateLimiter {
    return &RateLimiter{
        ch: make(chan struct{}, capacity),
    }
}

func (rl *RateLimiter) Acquire() {
    rl.ch <- struct{}{} // Send a struct to the channel, blocking if full
}

func (rl *RateLimiter) Release() {
    <-rl.ch // Receive from the channel, making room for another request
}

func main() {
    limiter := NewRateLimiter(5) // Allow 5 concurrent requests

    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            limiter.Acquire()
            defer limiter.Release()

            fmt.Printf("Processing request %d\n", id)
            time.Sleep(time.Millisecond * 200) // Simulate work
            fmt.Printf("Finished request %d\n", id)
        }(i)
    }

    wg.Wait()
    fmt.Println("All requests finished")
}

基于

golang.org/x/time/rate

的令牌桶限流器： Golang官方提供了一个

rate

包，实现了令牌桶算法。可以方便地创建一个令牌桶，并设置令牌的生成速率和桶的容量。

insMind

一站式AI图片和视频生成、编辑

下载

package main

import (
    "fmt"
    "sync"
    "time"

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

func main() {
    // r: 每秒允许多少个事件发生 (令牌生成速率)
    // b: 令牌桶的容量
    limiter := rate.NewLimiter(rate.Limit(5), 5) // 5 requests per second, burst of 5

    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()

            err := limiter.Wait(context.Background()) // Block until a token is available
            if err != nil {
                fmt.Printf("Error waiting: %v\n", err)
                return
            }

            fmt.Printf("Processing request %d\n", id)
            time.Sleep(time.Millisecond * 200) // Simulate work
            fmt.Printf("Finished request %d\n", id)
        }(i)
    }

    wg.Wait()
    fmt.Println("All requests finished")
}

基于Redis的分布式限流器： 如果需要对分布式系统进行限流，可以使用Redis的原子性操作来实现。例如，可以使用Redis的
```
INCR
```
命令来原子性地增加计数器，并设置过期时间，从而实现滑动窗口限流。

令牌桶与漏桶算法的区别是什么？

令牌桶算法允许一定程度的突发流量，因为桶里可以存储一定数量的令牌。而漏桶算法则会严格限制流量的速率，即使有空闲，也不会允许突发流量通过。令牌桶更适合需要处理突发流量的场景，而漏桶更适合需要平滑流量的场景。简单来说，令牌桶是“我允许你突发，但总量控制”，漏桶是“我必须平滑，不允许突发”。

如何选择合适的限流算法？

选择限流算法需要考虑以下因素：

业务场景： 不同的业务场景对流量的控制要求不同。例如，对于需要处理突发流量的场景，可以选择令牌桶算法。对于需要平滑流量的场景，可以选择漏桶算法。
系统架构： 如果是单机系统，可以使用基于Channel或
```
golang.org/x/time/rate
```
的限流器。如果是分布式系统，可以使用基于Redis的限流器。
性能要求： 不同的限流算法的性能不同。例如，基于Channel的限流器性能较高，但功能相对简单。基于Redis的限流器功能强大，但性能相对较低。