Was kann passieren, wenn ich die Antwort nicht schließe?

In Go habe ich einige http-Antworten und vergesse manchmal anzurufen:

resp.Body.Close()

Was passiert in diesem Fall? Wird es einen Speicherverlust geben? Ist es auch sicher, defer resp.Body.Close()sofort nach Erhalt des Antwortobjekts einzugeben?

client := http.DefaultClient
resp, err := client.Do(req)
defer resp.Body.Close()
if err != nil {
    return nil, err
}

Was ist, wenn ein Fehler vorliegt, der Null sein könnte respoder resp.Bodysein könnte ?

Was passiert in diesem Fall? Wird es einen Speicherverlust geben?

Es ist ein Ressourcenleck. Die Verbindung wird nicht wiederverwendet und kann offen bleiben. In diesem Fall wird der Dateideskriptor nicht freigegeben.

Ist es auch sicher, defer resp.Body.Close () sofort nach Erhalt des Antwortobjekts einzugeben?

Nein, folgen Sie dem Beispiel in der Dokumentation und schließen Sie es sofort, nachdem Sie den Fehler überprüft haben.

client := http.DefaultClient
resp, err := client.Do(req)
if err != nil {
    return nil, err
}
defer resp.Body.Close()

Aus der http.ClientDokumentation:

Wenn der zurückgegebene Fehler Null ist, enthält die Antwort einen Body ohne Null, den der Benutzer voraussichtlich schließen wird. Wenn der Body nicht sowohl in EOF gelesen als auch geschlossen wird, kann der zugrunde liegende RoundTripper des Clients (normalerweise Transport) eine dauerhafte TCP-Verbindung zum Server möglicherweise nicht für eine nachfolgende "Keep-Alive" -Anforderung wiederverwenden.

Wenn Response.Bodynicht mit Close()Methode geschlossen wird, werden Ressourcen, die einem fd zugeordnet sind, nicht freigegeben. Dies ist ein Ressourcenleck.

Schließen Response.Body

Aus der Antwortquelle :

Es liegt in der Verantwortung des Anrufers, Body zu schließen.

Es sind also keine Finalizer an das Objekt gebunden und es muss explizit geschlossen werden.

Fehlerbehandlung und verzögerte Bereinigung

Bei einem Fehler kann jede Antwort ignoriert werden. Eine Nicht-Null-Antwort mit einem Nicht-Null-Fehler tritt nur auf, wenn CheckRedirect fehlschlägt, und selbst dann ist die zurückgegebene Antwort bereits geschlossen.

resp, err := http.Get("http://example.com/")
if err != nil {
    // Handle error if error is non-nil
}
defer resp.Body.Close() // Close body only if response non-nil

Zunächst wird der Deskriptor nie geschlossen, wie oben erwähnt.

Und außerdem speichert Golang die Verbindung zwischen (wobei persistConnstruct zum Umbrechen verwendet wird ), um sie wiederzuverwenden , wenn sie DisableKeepAlivesfalsch ist.

In der Golang-After-Use- client.DoMethode führt go die Goroutine- readLoopMethode als einen der Schritte aus.

In golang http transport.gowird a pconn(persistConn struct)erst dann in den idleConnKanal eingefügt , wenn die Anforderung in der readLoopMethode abgebrochen wurde , und auch diese Goroutine ( readLoopMethode) wird blockiert, bis die Anforderung abgebrochen wird.

Hier ist der Code , der es zeigt.

Wenn Sie mehr wissen möchten, müssen Sie die readLoopMethode sehen.

Siehe https://golang.org/src/net/http/client.go.
"Wenn err null ist, enthält resp immer einen Nicht-null resp.Body."

aber sie sagen nicht, wenn err! = nil, resp ist immer nil. Sie fahren fort:
"Wenn resp.Body nicht geschlossen ist, kann der zugrunde liegende RoundTripper des Clients (normalerweise Transport) eine dauerhafte TCP-Verbindung zum Server möglicherweise nicht für eine nachfolgende" Keep-Alive "-Anforderung wiederverwenden."

Daher habe ich das Problem normalerweise folgendermaßen gelöst:

client := http.DefaultClient
resp, err := client.Do(req)
if resp != nil {
   defer resp.Body.Close()
}
if err != nil {
    return nil, err 
}

Könnte mir jemand sagen, wenn die Verbindung nicht ohne Schließen wiederverwendet werden kann, warum die Ausgabe von

package main

import (
    "context"
    "log"
    "net"
    "net/http"
)

func main() {
    connections := []net.Conn{}
    go func() {
        server := &http.Server{
            Addr: "127.0.0.1:8080",
            Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
                w.WriteHeader(http.StatusOK)
            }),
            ConnContext: func(ctx context.Context, c net.Conn) context.Context {
                connections = append(connections, c)
                return ctx
            },
        }
        log.Fatal(server.ListenAndServe())
    }()

    if _, err := http.Get("http://127.0.0.1:8080"); err != nil {
        log.Fatal(err)
    }
    log.Printf("first request done, %d connection", len(connections))
    if _, err := http.Get("http://127.0.0.1:8080"); err != nil {
        log.Fatal(err)
    }
    log.Printf("second request done, %d connection", len(connections))
    if len(connections) != 2 {
        log.Fatalf("Why %d, not 2?", len(connections))
    }
}

ist

2020/07/24 22:10:19 first request done, 1 connection
2020/07/24 22:10:19 second request done, 1 connection
2020/07/24 22:10:19 Why 1, not 2?