Go中AllowN使用异常：千级goroutine下限流失控问题排查

你的问题核心在于大量goroutine无限制自旋调用Allow()，导致rate.Limiter内部锁竞争过于激烈，令牌补充逻辑出现异常。

rate.Limiter的Allow()方法靠内部sync.Mutex保证线程安全，但1000个goroutine在无限循环中疯狂调用该方法时，锁会成为性能瓶颈：大量goroutine排队等待获取锁，当某个goroutine最终拿到锁时，距离上次令牌补充的时间已过去很久，此时rate.Limiter会一次性补充大量累积的令牌，这些令牌会被排队的goroutine瞬间消耗，直接突破限流阈值，出现“限流失控”的现象。

而减少goroutine数量或添加休眠时，锁竞争压力降低，令牌补充与消耗的节奏恢复正常，限流也就生效了。

方案1：改用Wait()方法替代Allow() #

Wait()会在无令牌时阻塞goroutine，直到令牌可用，避免无意义的自旋抢锁，能精准控制并发节奏：

func main() {
    var count int64 = 0
    limit := rate.NewLimiter(rate.Limit(100), 100)

    for i := 0; i < 1000; i++ {
        go func() {
            for {
                if err := limit.Wait(context.Background()); err == nil {
                    atomic.AddInt64(&count, 1)
                }
            }
        }()
    }

    start := time.Now().UnixMilli()
    for {
        last := count
        <-time.Tick(time.Second)
        fmt.Printf("current time[%d] allow %d\n", time.Now().UnixMilli()-start, count-last)
    }
}

方案2：在Allow()失败时添加休眠 #

若必须使用Allow()，可在获取令牌失败时让goroutine短暂休眠，降低锁竞争频率：

func main() {
    var count int64 = 0
    limit := rate.NewLimiter(rate.Limit(100), 100)

    for i := 0; i < 1000; i++ {
        go func() {
            for {
                if limit.Allow() {
                    atomic.AddInt64(&count, 1)
                } else {
                    // 短暂休眠减少锁竞争
                    time.Sleep(time.Millisecond * 1)
                }
            }
        }()
    }

    start := time.Now().UnixMilli()
    for {
        last := count
        <-time.Tick(time.Second)
        fmt.Printf("current time[%d] allow %d\n", time.Now().UnixMilli()-start, count-last)
    }
}

方案3：控制goroutine数量 #

通过工作池模式限制并发goroutine数量，从根源上降低锁竞争：

func main() {
    var count int64 = 0
    limit := rate.NewLimiter(rate.Limit(100), 100)
    // 限制并发goroutine数量为100
    workerChan := make(chan struct{}, 100)

    for i := 0; i < 1000; i++ {
        workerChan <- struct{}{}
        go func() {
            defer func() { <-workerChan }()
            for {
                if limit.Allow() {
                    atomic.AddInt64(&count, 1)
                }
            }
        }()
    }

    start := time.Now().UnixMilli()
    for {
        last := count
        <-time.Tick(time.Second)
        fmt.Printf("current time[%d] allow %d\n", time.Now().UnixMilli()-start, count-last)
    }
}

内容的提问来源于stack exchange，提问作者Mr.Question