Golang如何在多goroutine中实现限流器-Golang-PHP中文网

Golang如何在多goroutine中实现限流器

P粉602998670

发布： 2025-10-25 16:22:02

原创

222人浏览过

使用channel、rate包或自定义计数器实现Go限流。1. buffered channel控制并发数，通过信号量限制goroutine数量；2. golang.org/x/time/rate基于令牌桶限制请求速率；3. sync.Mutex配合计数器实现简单QPS控制，适用于轻量场景但需注意锁竞争。

golang如何在多goroutine中实现限流器

在Go语言中，多goroutine环境下实现限流器的常见方式是使用 channel 或标准库中的 sync.RWMutex 配合计数器，也可以借助第三方库如 golang.org/x/time/rate。下面介绍几种实用且高效的限流实现方法。

使用 buffered channel 实现并发数限制

这是最简单直观的方式：通过一个有缓冲的channel来控制同时运行的goroutine数量。

示例代码：

package main
<p>import (
"fmt"
"time"
)</p><p>func worker(id int, sem chan struct{}) {
defer func() { <-sem }() // 任务结束释放信号
fmt.Printf("Worker %d starting\n", id)
time.Sleep(1 * time.Second) // 模拟工作
fmt.Printf("Worker %d done\n", id)
}</p><p>func main() {
const maxConcurrency = 3
sem := make(chan struct{}, maxConcurrency)</p><pre class="brush:php;toolbar:false;"><pre class="brush:php;toolbar:false;">for i := 1; i <= 10; i++ {
    sem <- struct{}{} // 获取令牌
    go worker(i, sem)
}

// 等待所有任务完成（简化处理）
time.Sleep(5 * time.Second)

登录后复制

}

这个方法限制了最多只有3个goroutine同时运行。每当启动一个goroutine前先向channel写入数据，worker结束后从channel读出，从而实现“信号量”机制。

使用 golang.org/x/time/rate 实现速率限流

该包提供了基于令牌桶算法的限流器，适合控制请求频率，比如每秒最多N次调用。

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

示例代码：

package main
<p>import (
"fmt"
"sync"
"time"
"golang.org/x/time/rate"
)</p><p>func main() {
limiter := rate.NewLimiter(2, 5) // 每秒2个令牌，最多积压5个
var wg sync.WaitGroup</p><pre class="brush:php;toolbar:false;"><pre class="brush:php;toolbar:false;">for i := 0; i < 10; i++ {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        if err := limiter.Wait(nil); err != nil {
            fmt.Printf("Request %d failed: %v\n", id, err)
            return
        }
        fmt.Printf("Request %d processed at %v\n", id, time.Now())
    }(i)
    time.Sleep(100 * time.Millisecond) // 模拟请求到来
}

wg.Wait()

登录后复制

}

这种方式适用于接口级或API调用的速率控制，能平滑地限制单位时间内的请求数量。

多墨智能

多墨智能 - AI 驱动的创意工作流写作工具

108

查看详情

自定义计数器 + Mutex 实现简单QPS控制

如果不想引入外部依赖，可以自己实现一个简单的每秒请求数（QPS）限制器。

package main
<p>import (
"fmt"
"sync"
"time"
)</p><p>type RateLimiter struct {
mu       sync.Mutex
count    int
limit    int
interval time.Duration
lastReset time.Time
}</p><p>func NewRateLimiter(qps int, interval time.Duration) *RateLimiter {
return &RateLimiter{
limit:    qps,
interval: interval,
lastReset: time.Now(),
}
}</p><p>func (r *RateLimiter) Allow() bool {
r.mu.Lock()
defer r.mu.Unlock()</p><pre class="brush:php;toolbar:false;"><pre class="brush:php;toolbar:false;">now := time.Now()
if now.Sub(r.lastReset) > r.interval {
    r.count = 0
    r.lastReset = now
}

if r.count < r.limit {
    r.count++
    return true
}
return false

登录后复制

}

func main() { limiter := NewRateLimiter(3, time.Second) // 每秒最多3次 var wg sync.WaitGroup

for i := 0; i < 10; i++ {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        for !limiter.Allow() {
            time.Sleep(10 * time.Millisecond)
        }
        fmt.Printf("Processed request %d at %v\n", id, time.Now())
    }(i)
    time.Sleep(200 * time.Millisecond)
}

wg.Wait()

登录后复制

}

这种方法适合轻量级场景，但要注意锁竞争在高并发下可能成为瓶颈。

基本上就这些。根据实际需求选择合适的方式：channel适合控制并发数，rate.Limiter适合精确控制速率，自定义方案则灵活但需注意性能和正确性。不复杂但容易忽略的是资源释放和时钟漂移问题，尤其是长时间运行的服务。

以上就是Golang如何在多goroutine中实现限流器的详细内容，更多请关注php中文网其它相关文章！