Golang中关于HTTP的问题如何解决

Golang中关于HTTP的问题如何解决 我正在学习 Go 语言中的 HTTP 模块，在下面的代码中我忘记了添加 defer resp.Body.Close()，但整个程序仍然正常运行没有任何问题。我知道这行代码的作用是在整个程序完成后关闭 http.Get 返回的响应体。但我很好奇如果不加这行代码会有什么后果，因为我没有看到任何区别。

package main

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

func main() {

    resp, err := http.Get("http://gobyexample.com")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    fmt.Println("Response status:", resp.Status)

    scanner := bufio.NewScanner(resp.Body)
    for i := 0; scanner.Scan() && i < 5; i++ {
        fmt.Println(scanner.Text())
    }

    if err := scanner.Err(); err != nil {
        panic(err)
    }
}

更多关于Golang中关于HTTP的问题如何解决的实战教程也可以访问 https://www.itying.com/category-94-b0.html

2 回复

在你这个特定情况下，那一行代码无关紧要，因为在超时后关闭程序时，相关的 TCP 连接会停止。

对于需要处理大量请求的应用程序（例如并发请求）来说，这一点很重要，因为每个 TCP 连接都会在操作系统中打开一个文件描述符。因此，关闭连接将关闭文件描述符，否则在大量并发请求下，文件描述符可能会很快耗尽。

更多关于Golang中关于HTTP的问题如何解决的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


在Go语言中，如果不使用defer resp.Body.Close()，会导致资源泄漏。虽然你的示例程序可能没有立即表现出问题，但在生产环境或高并发场景下，这会逐渐耗尽系统资源。

问题分析：

  1. 每个HTTP响应体都是一个实现了io.ReadCloser接口的对象，它持有底层网络连接和缓冲区资源
  2. 如果不显式关闭，这些资源会一直保留直到垃圾回收器运行
  3. 在并发请求或长时间运行的程序中，未关闭的连接会累积，最终导致：
    • 文件描述符耗尽
    • 内存泄漏
    • 网络连接数达到上限

示例演示资源泄漏：

package main

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

func main() {
    // 监控内存使用
    go func() {
        for {
            var m runtime.MemStats
            runtime.ReadMemStats(&m)
            fmt.Printf("Alloc = %v MiB", m.Alloc/1024/1024)
            fmt.Printf("\tTotalAlloc = %v MiB", m.TotalAlloc/1024/1024)
            fmt.Printf("\tSys = %v MiB", m.Sys/1024/1024)
            fmt.Printf("\tNumGC = %v\n", m.NumGC)
            time.Sleep(5 * time.Second)
        }
    }()

    // 模拟多次请求而不关闭Body
    for i := 0; i < 1000; i++ {
        resp, err := http.Get("http://httpbin.org/get")
        if err != nil {
            fmt.Printf("Error: %v\n", err)
            continue
        }
        // 故意不调用 resp.Body.Close()
        
        // 读取少量数据确保请求完成
        buf := make([]byte, 1024)
        resp.Body.Read(buf)
        
        if i%100 == 0 {
            fmt.Printf("Completed %d requests\n", i)
        }
    }
    
    time.Sleep(30 * time.Second) // 观察资源变化
}

正确的处理方式：

package main

import (
    "io"
    "net/http"
)

func makeRequest(url string) error {
    resp, err := http.Get(url)
    if err != nil {
        return err
    }
    defer resp.Body.Close() // 确保资源被释放

    // 读取响应内容
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return err
    }
    
    // 处理body内容
    _ = body
    return nil
}

// 使用http.Client并确保关闭
func withCustomClient() error {
    client := &http.Client{}
    resp, err := client.Get("http://example.com")
    if err != nil {
        return err
    }
    defer resp.Body.Close() // 同样需要关闭
    
    return nil
}

关键点：

  • 即使程序很快结束，也应该保持关闭资源的习惯
  • defer语句确保在函数返回时执行关闭操作
  • 对于HTTP客户端，还可以考虑使用http.Client的Timeout设置和连接池管理
  • 在需要读取完整响应体的情况下，使用io.ReadAll()配合defer是标准做法

不关闭响应体会在长期运行的服务中导致严重的资源问题，这是Go语言HTTP编程中的基本最佳实践。

回到顶部