Go语言HTTP请求默认不超时导致Goroutine泄漏的问题

Go语言标准库中的 net/http 包极其易用，特别是通过 http.Get 或 http.Post 等便捷函数发起请求时。然而，这种便捷性掩盖了一个潜在的风险：默认情况下，HTTP客户端是没有超时设置的。一旦服务端响应缓慢或发生网络故障，负责请求的 Goroutine 将会一直阻塞，最终导致程序内存耗尽或服务不可用。为了防止这种情况，必须显式地为HTTP请求配置超时机制。

1. 理解问题根源

当直接调用 http.Get 时，Go 语言内部使用的是默认的 http.DefaultClient。查看源码可知，该客户端的 Timeout 字段被设置为 0，这意味着没有超时限制。

在以下代码中，如果服务端 httpbin.org/delay/10 模拟了 10 秒的延迟，客户端主函数会等待 10 秒。如果服务端永不响应（例如底层 TCP 连接挂起），客户端将永久阻塞。

package main

import (
    "fmt"
    "io"
    "net/http"
    "time"
)

func main() {
    // **发起**一个没有超时设置的请求
    resp, err := http.Get("http://httpbin.org/delay/10")
    if err != nil {
        fmt.Println("请求失败:", err)
        return
    }
    defer resp.Body.Close()

    // **读取**响应体
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

在高并发场景下，如果每一个请求都因为网络抖动而被卡住，程序内部的 Goroutine 数量会瞬间飙升，占用大量系统资源，最终引发 “OOM（Out of Memory）” 错误。

2. 解决方案一：使用全局超时设置（最简单）

对于简单的应用，最直接的修复方法是配置 http.Client 的 Timeout 字段。这个字段涵盖了从连接（Dial）、发送请求（Request）到读取响应体（Response）的全过程总时长。

执行以下步骤修改代码：

1. 创建一个自定义的 http.Client 实例。
2. 设置 Timeout 字段为期望的时间（例如 5 秒）。
3. 调用该实例的 Get 方法替代全局方法。

package main

import (
    "fmt"
    "io"
    "net/http"
    "time"
)

func main() {
    // **创建**自定义 Client
    client := &http.Client{
        // **设置**总超时时间为 2 秒
        Timeout: 2 * time.Second,
    }

    // **发起**请求
    resp, err := client.Get("http://httpbin.org/delay/10")
    if err != nil {
        // 此处会输出错误，因为 10秒 > 2秒
        fmt.Println("请求超时或失败:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

3. 解决方案二：使用 Context 实现细粒度控制（推荐）

在实际的生产环境中，仅仅设置一个全局的超时往往不够。例如，你可能需要在某个特定业务逻辑中止时立即取消请求，或者希望在连接建立后的读取阶段有不同的超时策略。这时，使用 context 包是最佳实践。

执行以下步骤实现基于 Context 的超时：

1. 引入 context 包。
2. 创建一个带有超时的上下文（使用 context.WithTimeout）。
3. 创建 http.Request 对象并绑定该上下文。
4. 调用 client.Do 发送请求。

package main

import (
    "context"
    "fmt"
    "io"
    "net/http"
    "time"
)

func main() {
    // **创建**自定义 Client（也可以不设置 Timeout，完全依赖 Context）
    client := &http.Client{}

    // **创建**带超时的 Context，这里设置 2 秒
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    // **确保**在函数退出时调用 cancel，释放资源
    defer cancel()

    // **构建** Request 对象
    req, err := http.NewRequestWithContext(ctx, "GET", "http://httpbin.org/delay/10", nil)
    if err != nil {
        fmt.Println("构建请求失败:", err)
        return
    }

    // **发起**请求
    resp, err := client.Do(req)
    if err != nil {
        // 当 Context 超时，err 会变为 context.DeadlineExceeded
        fmt.Println("请求失败:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

通过这种方式，当 2 秒时间一到，Context 会触发取消信号，底层的 HTTP 连接会被强制中断，Goroutine 随即释放，不再阻塞。

4. 区分不同阶段的超时

为了更精准地控制，可以针对连接阶段和传输阶段分别设置超时。这种方式适用于需要对“建连”和“数据传输”有不同容忍度的场景。

参考下表配置参数：

配置 Transport 的示例代码如下：

package main

import (
    "fmt"
    "net/http"
    "time"
)

func main() {
    // **自定义** Transport
    tr := &http.Transport{
        // **设置** TCP 连接超时
        DialContext: (&net.Dialer{
            Timeout:   3 * time.Second,
        }).DialContext,
        // **设置**等待响应头超时
        ResponseHeaderTimeout: 2 * time.Second,
    }

    // **实例化** Client
    client := &http.Client{
        Transport: tr,
        // **设置**整体超时兜底
        Timeout: 10 * time.Second,
    }

    resp, err := client.Get("http://httpbin.org/delay/10")
    if err != nil {
        fmt.Println("请求出错:", err)
        return
    }
    defer resp.Body.Close()

    fmt.Println("请求状态码:", resp.StatusCode)
}

5. 请求生命周期与取消流程

理解 Context 是如何中断 HTTP 请求的非常重要。下图描述了从创建 Context 到最终连接关闭的完整流程。

注意：必须显式调用 cancel() 函数（通常通过 defer cancel()），即使请求已经成功返回。这能确保 Context 关联的所有定时器资源被及时回收。

6. 常见错误排查

在实施上述方案后，如果遇到 context deadline exceeded 错误，请按以下逻辑排查：

1. 检查服务端处理速度。如果服务端确实处理时间超过了你的设定，需根据业务逻辑调大超时时间。
2. 检查网络状况。如果网络延迟高，需增加 DialContext 的超时设置。
3. 检查响应体读取。即使请求返回了，如果响应体很大且读取速度慢，仍可能触发总超时。确保使用了 io.Copy 或带缓冲的读取方式。

排查超时原因的代码示例：

resp, err := client.Do(req)
if err != nil {
    // **判断**是否为超时错误
    if err == context.DeadlineExceeded {
        fmt.Println("错误: 请求在规定时间内未完成")
    } else if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
        fmt.Println("错误: 网络层超时（如连接握手失败）")
    } else {
        fmt.Println("错误: 其他网络错误", err)
    }
    return
}