当前位置：首页 > 文章列表 > Golang > Go教程 > 使用 Channel 实现限流器的思路是通过控制并发数量，限制同时处理的请求量。Go 语言中的 channel 可以很好地实现这一功能。示例：基于 Channel 的限流器package main import ( "fmt" "time" ) func main() { // 定义一个缓冲通道，容量为3，表示最多允许3个并发请求 limit := make(c

使用 Channel 实现限流器的思路是通过控制并发数量，限制同时处理的请求量。Go 语言中的 channel 可以很好地实现这一功能。示例：基于 Channel 的限流器package main import ( "fmt" "time" ) func main() { // 定义一个缓冲通道，容量为3，表示最多允许3个并发请求 limit := make(c

2026-05-07 12:35:51 0浏览收藏

本文深入探讨了如何在 Go 语言中基于 channel 实现高效、可控的限流器，从简单的缓冲 channel（如 `make(chan struct{}, 3)`）起步，直观演示并发控制原理；同时指出其本质局限——chan struct{} 仅能表达“有/无”状态，缺乏计数能力，无法安全支持批量获取/释放许可、可重入或动态调整等复杂场景；进而引出工业级解决方案：结合 sync.Mutex 管理可用许可数、用带缓冲 channel 协同分发令牌，构建线程安全、支持 Acquire(n)/Release(n) 的轻量信号量，并给出可直接落地的封装示例，兼顾简洁性与生产可靠性。

用 channel 实现类似 semaphore 的限流器

为什么不能直接用 `chan struct{}` 做信号量

Go 的 channel 本身没有“计数”能力，chan struct{} 只能表达“有/无”，无法安全支持多次 Acquire 后再统一 Release —— 比如你想允许最多 5 个并发，但某个协程可能一次拿走 2 个许可，另一个只还 1 个，这时候光靠 channel 关闭/阻塞逻辑就乱了。标准库没有 semaphore，得自己包一层状态控制。

用带缓冲的 channel + 互斥锁实现可重入、可批量操作的限流器

核心思路：用 chan struct{} 管理“空闲许可”的分发，用 sync.Mutex 保护剩余数量（available），这样既能支持 Acquire(n) 和 Release(n)，又能避免 channel 容量被误读（比如 len(ch) 不是实时可用数，因为有 goroutine 正在 recv 但还没完成）。

实操建议：

初始化时往带缓冲 channel 写入 n 个 struct{}，代表初始许可数
Acquire(n) 先加锁检查 available >= n，满足才从 channel 读取 n 次；不满足就解锁后阻塞在 channel 上（或用 select 加超时）
Release(n) 加锁更新 available += n，然后往 channel 写入 n 次 —— 注意这里必须确保写入成功，所以 channel 缓冲区大小要 ≥ 最大许可数
不要依赖 cap(ch) 或 len(ch) 判断状态，它们和业务语义不一致

一个轻量但线程安全的实现示例

type Semaphore struct {
    ch        chan struct{}
    mu        sync.Mutex
    available int
    limit     int
}
func NewSemaphore(limit int) *Semaphore {
ch := make(chan struct{}, limit)
for i := 0; i < limit; i++ {
ch <- struct{}{}
}
return &Semaphore{
ch:        ch,
available: limit,
limit:     limit,
}
}
func (s *Semaphore) Acquire(n int) bool {
s.mu.Lock()
if s.available >= n {
s.available -= n
s.mu.Unlock()
for i := 0; i < n; i++ {
<-s.ch
}
return true
}
s.mu.Unlock()
// 阻塞式获取：也可改用 select + timeout
for i := 0; i < n; i++ {
<-s.ch
}
s.mu.Lock()
s.available -= n
s.mu.Unlock()
return true
}
func (s *Semaphore) Release(n int) {
s.mu.Lock()
s.available += n
s.mu.Unlock()
for i := 0; i < n; i++ {
s.ch <- struct{}{}
}
}

注意：Acquire 中两次加锁/解锁之间不能有 channel 操作，否则可能死锁；Release 的写入必须发生在加锁之后更新 available，否则并发 Acquire 可能读到过期值。