性能问题：在 Go 中使用 DialContext

在 Go 中使用 DialContext 可以显著提升性能。通过对 HTTP 客户端进行基准测试，发现 DialContext 可将响应时间从 731.154103 毫秒降低至 2.266333805 秒。通过使用 Net/http/Httptrace，发现 DialContext 通过打开更多新连接来提高速度，同时确保响应正文已完全读取并关闭。

我使用 go 的内置 http.client 和 net 进行了快速基准测试。与不使用 dialcontext 时相比，它会导致一些明显的性能问题。

我基本上是在尝试模仿我们公司的一个用例，其中 http.client 设置在用于完全相同的事情时比默认配置的性能要低得多。我注意到评论 dialcontext 部分使它运行得更快。

基准测试只是打开一个线程池（示例中为 8 个）来创建到简单 url 的连接，使用大小与线程数 (8) 相同的缓冲通道。

这是 dialcontext 的代码（2.266333805s）：

func main() {
    var httpclient *http.client

    httpclient = &http.client{
        transport: &http.transport{
            dialcontext: (&net.dialer{
                timeout:   3 * time.second,
                keepalive: 30 * time.second,
                dualstack: true,
            }).dialcontext,
        },
    }

    url := "https://stackoverflow.com/"
    wg := sync.waitgroup{}
    threads := 8
    wg.add(threads)
    c := make(chan struct{}, threads)

    start := time.now()
    for i := 0; i < threads; i++ {
        go func() {
            for range c {
                req, _ := http.newrequest(http.methodget, url, nil)
                resp, err := httpclient.do(req)
                if err == nil {
                    resp.body.close()
                }
            }
            wg.done()
        }()
    }

    for i := 0; i < 200; i++ {
        c <- struct{}{}
    }
    close(c)
    wg.wait()

    fmt.println(time.since(start))
}

输出时间为2.266333805s

这是没有 dialcontext 的代码（731.154103ms）：

func main() {
    var httpclient *http.client

    httpclient = &http.client{
        transport: &http.transport{
        },
    }

    url := "https://stackoverflow.com/"
    wg := sync.waitgroup{}
    threads := 8
    wg.add(threads)
    c := make(chan struct{}, threads)

    start := time.now()
    for i := 0; i < threads; i++ {
        go func() {
            for range c {
                req, _ := http.newrequest(http.methodget, url, nil)
                resp, err := httpclient.do(req)
                if err == nil {
                    resp.body.close()
                }
            }
            wg.done()
        }()
    }

    for i := 0; i < 200; i++ {
        c <- struct{}{}
    }
    close(c)
    wg.wait()

    fmt.println(time.since(start))
}

输出时间为731.154103ms

多次运行程序后结果之间的差异是一致的。

有人知道为什么会发生这种情况吗？

谢谢！

编辑：所以我尝试了 net/http/httptrace 并确保响应正文已完全阅读并关闭：

go func() {
    for range c {
        req, _ := http.newrequest(http.methodget, url, nil)
        req = req.withcontext(httptrace.withclienttrace(req.context(), &httptrace.clienttrace{
            gotconn: t.gotconn,
        }))
        resp, _ := httpclient.do(req)
        ioutil.readall(resp.body)
        resp.body.close()
    }
    wg.done()
}()

使用 dialcontext 与不使用它时的发现很有趣。

不使用 dialcontext：

time taken to run 200 requests: 5.639808793s
new connections: 1
reused connections: 199

使用 dialcontext：

time taken to run 200 requests: 5.682882723s
new connections: 8
reused connections: 192

速度更快...但为什么一个打开 8 个新连接，而另一个只打开 1 个？

解决方案

获得如此大差异的唯一方法是一种传输正在重用连接，而另一种则没有。为了确保您可以重用连接，您必须始终读取响应正文。在某些情况下，连接可能会在不显式读取正文的情况下被重用，但这永远无法保证，并且取决于许多事情，例如远程服务器关闭连接、transport 是否完全缓冲响应以及是否存在请求的上下文。

net/http/httptrace 包可以让您深入了解许多请求的内部情况，包括连接是否被重用。有关示例，请参阅 https://blog.golang.org/http-tracing。

设置 disablekeepalive 将始终阻止连接被重用，从而使两者同样变慢。始终像这样阅读响应将使两者同样快速：

req, _ := http.NewRequest(http.MethodGet, url, nil)
resp, err := httpClient.Do(req)
if err != nil {
    // handle error
    continue
}
io.Copy(ioutil.Discard, resp.Body)
resp.Body.Close()

如果您想在断开连接之前限制可以读取的内容，您可以简单地将正文包装在 io.LimitedReader 中

好了，本文到此结束，带大家了解了《性能问题：在 Go 中使用 DialContext》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！