不能直接用 chan struct{} 做信号量，因其无计数能力，仅能表达“有/无”，无法安全支持多次 Acquire 后统一 Release；需结合 sync.Mutex 管理可用数量，或直接使用 golang.org/x/sync/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
}
<p>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,
}
}</p><p>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
}</p><p>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 可能读到过期值。
比 channel 更适合的替代方案：使用 golang.org/x/sync/semaphore
如果你只是需要标准语义的信号量（支持权重、上下文取消、公平性），别重复造轮子。semaphore.Weighted 就是专为此设计的：
-
Acquire(ctx, n)支持超时和取消 - 内部用
runtime_Semacquire+ 队列，比纯 channel 实现更高效、更少内存分配 - 已通过大量压测，边界 case（如
n=0、并发抢占、panic 后释放）都处理好了 - 引入方式：
go get golang.org/x/sync/semaphore
真正难的不是“怎么用 channel 模拟”，而是想清楚要不要承担自己维护状态同步、公平性、取消传播这些复杂性的成本。
