Go语言http.Client通过RoundTrip限流失效并触发致命Panic

需求目标 #

设置每分钟600次请求的限流规则，每分钟重置一次。计划通过http.Client配置带有limit.Wait()的RoundTrip实现，为不同http.Client实例设置不同限流规则，将限流逻辑交由RoundTrip处理，避免增加业务代码复杂度。

问题现象 #

• 限流规则未生效，请求次数远超限制；
• 设置客户端超时后触发错误：net/http: request canceled (Client.Timeout exceeded while awaiting headers)，甚至引发异常。

复现情况 #

编写极简版main.go复现问题，其中64000次循环模拟真实业务场景：

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "sync"
    "time"

    "golang.org/x/time/rate"
)

var client http.Client

// ThrottledTransport Rate Limited HTTP Client
type ThrottledTransport struct {
    roundTripperWrap http.RoundTripper
    ratelimiter      *rate.Limiter
}

func (c *ThrottledTransport) RoundTrip(r *http.Request) (*http.Response, error) {
    err := c.ratelimiter.Wait(r.Context()) // This is a blocking call. Honors the rate limit
    if err != nil {
        return nil, err
    }
    return c.roundTripperWrap.RoundTrip(r)
}

// NewRateLimitedTransport wraps transportWrap with a rate limitter
func NewRateLimitedTransport(transportWrap http.RoundTripper) http.RoundTripper {
    return &ThrottledTransport{
        roundTripperWrap: transportWrap,
        //ratelimiter:      rate.NewLimiter(rate.Every(limitPeriod), requestCount),
        ratelimiter: rate.NewLimiter(10, 10),
    }
}

func main() {
    concurrency := 20
    var ch = make(chan int, concurrency)
    var wg sync.WaitGroup

    wg.Add(concurrency)
    for i := 0; i < concurrency; i++ {
        go func() {
            for {
                a, ok := <-ch
                if !ok { // if there is nothing to do and the channel has been closed then end the goroutine
                    wg.Done()
                    return
                }
                resp, err := client.Get("https://api.guildwars2.com/v2/items/12452")
                if err != nil {
                    fmt.Println(err)
                }
                body, err := ioutil.ReadAll(resp.Body)
                if err != nil {
                    fmt.Println(err)
                }
                fmt.Println(a, ":", string(body[4:29]))
            }
        }()
    }
    client = http.Client{}
    client.Timeout = time.Second * 10

    // Rate limits 600 requests per 60 seconds via RoundTripper
    transport := NewRateLimitedTransport(http.DefaultTransport)
    client.Transport = transport

    for i := 0; i < 64000; i++ {
        ch <- i // add i to the queue
    }

    wg.Wait()
    fmt.Println("done")
}

更新补充 #

即使将限流器改为rate.NewLimiter(10, 10)，仍会超出600次/分钟的限流限制，同时触发Context deadline exceeded错误。

问题根源分析 #

1. 初始化顺序错误：goroutine启动时已引用全局client变量，但此时client尚未配置限流Transport；后续修改client.Transport的操作对已启动的goroutine无效，导致这些goroutine使用默认Transport发起请求，完全不受限流约束。
2. Context超时冲突：ratelimiter.Wait(r.Context())使用的是请求自带的Context，而该Context受client.Timeout限制。当请求等待限流令牌的时间超过客户端超时时间时，Context会先触发超时，直接取消请求，引发超时错误。
3. 通道未关闭：main函数发送完所有任务后未关闭通道，导致goroutine一直阻塞在<-ch操作上，wg.Wait()永远无法完成，程序无法正常退出。
4. 限流器配置错误：当前rate.NewLimiter(10,10)的配置是每秒10次、突发10次，但要实现每分钟600次且每分钟重置的规则，该配置不符合需求，且burst值过小会导致不必要的等待阻塞。

修复方案 #

1. 调整初始化顺序

先完成client的限流配置，再启动goroutine，确保所有goroutine都使用带限流的客户端：

func main() {
    concurrency := 20
    var ch = make(chan int, concurrency)
    var wg sync.WaitGroup

    // 先配置带限流的client
    client = http.Client{}
    client.Timeout = time.Second * 10
    // 正确配置限流器：每分钟600次 = 每秒10次，burst设为600允许每分钟突发全量请求
    transport := &ThrottledTransport{
        roundTripperWrap: http.DefaultTransport,
        ratelimiter:      rate.NewLimiter(rate.Limit(600)/60, 600),
    }
    client.Transport = transport

    // 再启动goroutine
    wg.Add(concurrency)
    for i := 0; i < concurrency; i++ {
        go func() {
            defer wg.Done()
            for a := range ch { // 直接遍历通道，通道关闭时自动退出
                resp, err := client.Get("https://api.guildwars2.com/v2/items/12452")
                if err != nil {
                    fmt.Println(err)
                    continue
                }
                // 必须关闭resp.Body，避免连接泄漏
                defer resp.Body.Close()
                body, err := ioutil.ReadAll(resp.Body)
                if err != nil {
                    fmt.Println(err)
                    continue
                }
                fmt.Println(a, ":", string(body[4:29]))
            }
        }()
    }

    for i := 0; i < 64000; i++ {
        ch <- i
    }
    close(ch) // 发送完任务后关闭通道

    wg.Wait()
    fmt.Println("done")
}

2. 分离限流等待与请求的Context

为限流等待单独创建不受客户端超时约束的Context，避免等待令牌时触发请求超时：

import "context"

func (c *ThrottledTransport) RoundTrip(r *http.Request) (*http.Response, error) {
    // 创建独立的Context，仅在程序退出时取消
    waitCtx, cancel := context.WithCancel(context.Background())
    defer cancel()
    // 监听原始请求的Context，若请求取消则同时取消等待
    go func() {
        select {
        case <-r.Context().Done():
            cancel()
        case <-waitCtx.Done():
        }
    }()
    err := c.ratelimiter.Wait(waitCtx)
    if err != nil {
        return nil, err
    }
    return c.roundTripperWrap.RoundTrip(r)
}

3. 修复资源泄漏

确保每次请求后关闭resp.Body，避免HTTP连接池资源耗尽。

内容的提问来源于stack exchange，提问作者Rien