当前位置：首页 > 文章列表 > Golang > Go教程 > Golang并发限速实现技巧

Golang并发限速实现技巧

2026-01-05 11:11:52 0浏览收藏

在Golang实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《Golang 限速并发任务实现方法》，聊聊，希望可以帮助到正在努力赚钱的你。

答案：Golang中通过令牌桶算法实现限速任务调度，可使用rate.Limiter或自定义TokenBucket控制并发。

Golang 如何实现限速并发任务执行_Golang Token Bucket 限流算法实战

在高并发场景下，控制任务执行速率是保障系统稳定的关键。Golang 中通过 Token Bucket（令牌桶） 算法实现限速并发任务是一种常见且高效的方式。它既能平滑控制请求速率，又能应对突发流量。下面介绍如何用 Go 实现一个基于 Token Bucket 的限速任务调度器。

Token Bucket 原理简述

令牌桶算法维护一个固定容量的“桶”，以恒定速率向桶中添加令牌。每次执行任务前必须从桶中获取一个令牌，若桶空则等待。这种方式允许一定程度的突发请求（只要桶中有令牌），同时长期速率受生成速率限制。

Go 标准库 golang.org/x/time/rate 提供了开箱即用的 rate.Limiter，底层正是基于令牌桶实现。

使用 rate.Limiter 控制任务并发速率

假设我们需要每秒最多执行 5 个任务，可以这样实现：

package main
import (
"context"
"fmt"
"math/rand"
"sync"
"time"
"golang.org/x/time/rate"
)
func main() {
// 每秒产生 5 个令牌，桶容量为 10（允许短暂突发）
limiter := rate.NewLimiter(5, 10)
var wg sync.WaitGroup
ctx := context.Background()
tasks := make([]func(), 20)
for i := 0; i < 20; i++ {
    taskID := i
    tasks[i] = func() {
        defer wg.Done()
        // 等待获取一个令牌
        if err := limiter.Wait(ctx); err != nil {
            fmt.Printf("任务 %d 被取消: %v\n", taskID, err)
            return
        }

        // 模拟任务执行（耗时随机）
        duration := time.Duration(rand.Intn(300)) * time.Millisecond
        time.Sleep(duration)
        fmt.Printf("任务 %d 执行完成，耗时 %v\n", taskID, duration)
    }
}

// 并发启动所有任务
for _, task := range tasks {
    wg.Add(1)
    go task()
}

wg.Wait()
fmt.Println("所有任务完成")
}

上面代码中：

rate.NewLimiter(5, 10) 表示每秒生成 5 个令牌，桶最多存 10 个。
limiter.Wait(ctx) 会阻塞直到拿到令牌，适合同步控制。
使用 context 可支持超时或取消任务。

自定义 Token Bucket 实现（无第三方依赖）

如果不想引入 x/time/rate，也可以手写一个简单的令牌桶：

type TokenBucket struct {
    capacity  int64         // 桶容量
    tokens    int64         // 当前令牌数
    rate      time.Duration // 每产生一个令牌的时间间隔
    lastGrant time.Time     // 上次发放令牌时间
    mu        sync.Mutex
}
func NewTokenBucket(capacity int64, rps float64) *TokenBucket {
interval := time.Second / time.Duration(rps) // 每秒 rps 个令牌
return &TokenBucket{
capacity:  capacity,
tokens:    capacity,
rate:      interval,
lastGrant: time.Now(),
}
}
func (tb *TokenBucket) Allow() bool {
tb.mu.Lock()
defer tb.mu.Unlock()
now := time.Now()
// 补充令牌
elapsed := now.Sub(tb.lastGrant)
newTokens := int64(elapsed / tb.rate)
if newTokens > 0 {
    tb.tokens = min(tb.capacity, tb.tokens+newTokens)
    tb.lastGrant = now
}

if tb.tokens > 0 {
    tb.tokens--
    return true
}
return false
}
func min(a, b int64) int64 {
if a < b {
return a
}
return b
}

使用方式：

bucket := NewTokenBucket(10, 5.0) // 每秒5个，最多10个
for i := 0; i < 20; i++ {
for !bucket.Allow() {
time.Sleep(10  time.Millisecond) // 等待可用令牌
}
go func(id int) {
fmt.Printf("执行任务 %d\n", id)
}(i)
time.Sleep(1  time.Millisecond) // 避免 goroutine 创建过快
}