使用channel、rate包或自定义计数器实现Go限流。1. buffered channel控制并发数，通过信号量限制goroutine数量；2. golang.org/x/time/rate基于令牌桶限制请求速率；3. sync.Mutex配合计数器实现简单QPS控制，适用于轻量场景但需注意锁竞争。
在Go语言中，多goroutine环境下实现限流器的常见方式是使用 channel 或标准库中的 sync.RWMutex 配合计数器，也可以借助第三方库如 golang.org/x/time/rate。下面介绍几种实用且高效的限流实现方法。
使用 buffered channel 实现并发数限制
这是最简单直观的方式：通过一个有缓冲的channel来控制同时运行的goroutine数量。
示例代码：package mainimport ( "fmt" "time" )
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) }
func main() { const maxConcurrency = 3 sem := make(chan struct{}, maxConcurrency)
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 mainimport ( "fmt" "sync" "time" "golang.org/x/time/rate" )
func main() { limiter := rate.NewLimiter(2, 5) // 每秒2个令牌，最多积压5个 var wg sync.WaitGroup
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调用的速率控制，能平滑地限制单位时间内的请求数量。
自定义计数器 + Mutex 实现简单QPS控制
如果不想引入外部依赖，可以自己实现一个简单的每秒请求数（QPS）限制器。
package mainimport ( "fmt" "sync" "time" )
type RateLimiter struct { mu sync.Mutex count int limit int interval time.Duration lastReset time.Time }
func NewRateLimiter(qps int, interval time.Duration) *RateLimiter { return &RateLimiter{ limit: qps, interval: interval, lastReset: time.Now(), } }
func (r *RateLimiter) Allow() bool { r.mu.Lock() defer r.mu.Unlock()
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适合精确控制速率，自定义方案则灵活但需注意性能和正确性。不复杂但容易忽略的是资源释放和时钟漂移问题，尤其是长时间运行的服务。
