Go语言http.Server的ReadTimeout与WriteTimeout配置

在 Web 服务开发中，如果不合理配置超时参数，服务器极易受到“慢速攻击”或因网络抖动导致大量连接堆积，最终耗尽内存或文件描述符。Go 语言的 http.Server 提供了 ReadTimeout 和 WriteTimeout 两个核心配置来管控连接生命周期。

本文将通过实际代码和原理分析，指导你如何正确配置这两个参数，以确保服务的高可用性。

理解超时机制的生命周期

在编写代码前，必须先厘清这两个超时参数分别控制连接的哪个阶段。直接看文字描述可能比较抽象，我们可以通过一个时序图来理解时间轴上的临界点。

根据上述流程，我们可以得出核心定义：

• ReadTimeout：从连接接受（Accept）开始，到请求体完全读取（Read）结束。如果客户端发送数据太慢（例如恶意地每秒发送 1 字节），超过此时间服务端直接断开。
• WriteTimeout：从请求头读取完成开始，到响应体写入（Write）结束。如果服务端处理逻辑太慢，或者客户端接收响应太慢（网络拥塞），超过此时间连接断开。

注意：$T_{Write}$ 实际上包含了 Handler 的业务处理时间。如果你的业务逻辑耗时 5 秒，而 WriteTimeout 设置为 3 秒，客户端会收到超时错误。

步骤一：编写基础配置代码

我们摒弃默认的 http.ListenAndServe 封装，直接实例化 http.Server 结构体，以便精细控制参数。

1. 打开 你的 Go 项目入口文件（通常是 main.go）。
2. 导入 net/http、time 和 fmt 包。
3. 定义 一个简单的 Handler 函数用于测试。
4. 实例化 http.Server 结构体，并设置 ReadTimeout 和 WriteTimeout。

参考以下代码结构：

package main

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

func main() {
    // 1. 定义处理逻辑
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        // 模拟业务处理耗时
        time.Sleep(2 * time.Second)
        io.WriteString(w, "Hello, World!")
    })

    // 2. 配置 Server 结构体
    srv := &http.Server{
        Addr:         ":8080",
        Handler:      mux,
        // 设置读取超时为 5 秒
        ReadTimeout:  5 * time.Second,
        // 设置写入超时为 5 秒（包含业务处理时间）
        WriteTimeout: 5 * time.Second,
    }

    // 3. 启动服务
    fmt.Println("Server starting on :8080...")
    if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
        panic(err)
    }
}

在上述代码中：

• ReadTimeout: 5 * time.Second 意味着客户端必须在 5 秒内发完 HTTP 请求头和 Body。
• WriteTimeout: 5 * time.Second 意味着从读取完请求头开始，必须在 5 秒内发完响应。由于我们的 time.Sleep 模拟了 2 秒处理时间，只要网络传输在 3 秒内完成，就不会超时。

步骤二：根据业务场景设定数值

不同类型的业务对超时的敏感度不同。切忌直接照搬网上的“通用配置”，需根据实际需求调整。

请参考下表，根据你的应用类型选择合适的基准值：

步骤三：处理超时后的上下文

当超时发生时，Go 服务器会自动断开连接。但为了防止 Goroutine 泄漏（即业务逻辑还在跑，但连接已经断了），你需要利用 Request.Context() 来感知超时事件。

1. 修改 Handler 逻辑，增加 select 监听。
2. 检查 ctx.Done() 状态。

优化后的代码示例如下：

mux.HandleFunc("/long-task", func(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()

    // 模拟一个耗时任务，每秒检查一次上下文
    result := 0
    for i := 0; i < 10; i++ {
        select {
        case <-time.After(1 * time.Second):
            result += i
        case <-ctx.Done():
            // 如果超时或客户端取消，这里会被触发
            fmt.Println("Client disconnected or timeout:", ctx.Err())
            return // 立即停止处理
        }
    }

    io.WriteString(w, fmt.Sprintf("Result: %d", result))
})

关键动作：

• 务必 在循环或长耗时操作中检查 <-ctx.Done()。
• 立即 使用 return 退出函数，释放资源。

步骤四：避坑指南与进阶配置

在实际生产环境中，仅仅设置 ReadTimeout 和 WriteTimeout 可能会遇到特定问题，需注意以下细节。

1. 闲置超时 (IdleTimeout)

如果开启了 HTTP Keep-Alive，客户端可能会长时间占用连接但不发请求。为了清理这些“僵尸连接”，需要设置 IdleTimeout。

srv := &http.Server{
    Addr:         ":8080",
    ReadTimeout:  5 * time.Second,
    WriteTimeout: 10 * time.Second,
    // 如果 120 秒内没有新请求，则关闭连接
    IdleTimeout:  120 * time.Second,
}

2. ReadHeaderTimeout 的妙用

ReadTimeout 是“读取完整个请求”的超时时间。如果攻击者只发送 Header 不发 Body（Slowloris 攻击变体），连接会一直占用直到 ReadTimeout 耗尽。

为了更快地拒绝恶意连接，可以单独设置 ReadHeaderTimeout（读取请求头的超时）。

srv := &http.Server{
    Addr:            ":8080",
    ReadHeaderTimeout: 2 * time.Second, // 只要 2 秒内没读完 Header，直接断开
    ReadTimeout:     10 * time.Second,  // 完整请求读取超时
    WriteTimeout:    10 * time.Second,
}

3. 全站 HTTPS 的陷阱

如果你使用 ListenAndServeTLS 启动服务，且未设置 ReadTimeout，Go 的 TLS 握手过程可能会因为超时设置不当而阻塞。务必在 HTTPS 模式下显式设置上述所有超时参数。

验证配置效果

配置完成后，不要直接上线，使用 curl 命令在本地进行超时测试。

1. 测试读取超时：
   编写一个客户端脚本，建立连接后暂停发送数据，观察服务端是否在配置时间（如 5 秒）后断开。

2. 测试写入超时：
   在 Handler 中 Sleep 超过 WriteTimeout 的时间，观察是否返回 408 Request Timeout 或连接直接重置。

# 模拟慢速发送请求（每 2 秒发送一个字节，发送 10 次）
# 如果 ReadTimeout < 20s，连接应当被断开
(echo -n "H"; sleep 2; echo -n "e"; sleep 2; echo -n "l"; sleep 2; echo -n "l"; sleep 2; echo -n "o"; sleep 10) | nc localhost 8080

通过以上步骤，你已经构建了一个具备基本自我保护能力的 HTTP 服务。合理设置 ReadTimeout 和 WriteTimeout 是保障服务稳定性最廉价也最有效的手段。