使用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 main <p>import ( "fmt" "time" )</p><p>func worker(id int, sem chan struct{}) { defer func() { <-sem }() // 任务结束释放信号 fmt.Printf("Worker %d startingn", id) time.Sleep(1 * time.Second) // 模拟工作 fmt.Printf("Worker %d donen", 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: %vn", id, err) return } fmt.Printf("Request %d processed at %vn", id, time.Now()) }(i) time.Sleep(100 * time.Millisecond) // 模拟请求到来 } wg.Wait()
}
这种方式适用于接口级或api调用的速率控制，能平滑地限制单位时间内的请求数量。
自定义计数器 + 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 %vn", id, time.Now()) }(i) time.Sleep(200 * time.Millisecond) } wg.Wait()
}
这种方法适合轻量级场景，但要注意锁竞争在高并发下可能成为瓶颈。
基本上就这些。根据实际需求选择合适的方式：channel适合控制并发数，rate.Limiter适合精确控制速率，自定义方案则灵活但需注意性能和正确性。不复杂但容易忽略的是资源释放和时钟漂移问题，尤其是长时间运行的服务。