Golang http-Verbindung schließen

Wenn wir Golang für die HTTP-Programmierung verwenden, müssen wir oft darüber nachdenken, wie wir die Verbindung schließen können. Durch das Schließen von Verbindungen können Ressourcenverschwendung effektiv vermieden, die Leistung verbessert und unnötige Probleme durch Netzwerkprobleme reduziert werden. In diesem Artikel wird detailliert beschrieben, wie HTTP-Verbindungen in Golang geschlossen werden, und einige Details werden analysiert.

1. So schließen Sie die HTTP-Verbindung

Der HTTP-Client und -Server in der Go-Sprache implementieren eine Reihe zugrunde liegender Prozesse, um HTTP-Verbindungen zu verwalten. Diese Low-Level-Verarbeitung wird dem Benutzer normalerweise nicht angezeigt, sondern wird in der internen Implementierung von HTTP-Clients und -Servern verborgen. Wie kann man also die Verbindung zwischen HTTP-Client und -Server schließen?

1. HTTP-Client

Im HTTP-Client haben wir mehrere Möglichkeiten, die Verbindung zu schließen:

#🎜🎜 #Verwenden Sie das Schlüsselwort defer, um die Verbindung manuell zu schließen: Nachdem der Client die Schnittstelle aufgerufen hat, wird die Verbindung im Allgemeinen automatisch geschlossen. Wenn der aktuelle Client die Schnittstelle jedoch mehrmals anfordern muss, können Sie erwägen, das Schließen der Verbindung manuell zu steuern und das Schließen der Verbindung mit „defer“ zu verzögern. Der Code lautet wie folgt:

• package main
  import (
      "net/http"
      "io/ioutil"
      "fmt"
      "log"
  )
  func main() {
      client := &http.Client{}
      req, err := http.NewRequest("GET", "http://www.baidu.com", nil)
      if err != nil {
          log.Fatal(err)
      }
      defer client.CloseIdleConnections() // 当函数返回时释放连接
      resp, err := client.Do(req)
      if err != nil {
          log.Fatal(err)
      }
      defer resp.Body.Close() // 当函数返回时关闭body
      body, err := ioutil.ReadAll(resp.Body)
      if err != nil {
          log.Fatal(err)
      }
      fmt.Println(string(body)[:50])
  }

# 🎜🎜#Verwenden Sie MaxIdleConns der Transport-Klasse oder MaxIdleConnsPerHost, um die Obergrenze der Verbindungen im Verbindungspool zu steuern: http.Transport der Go-Sprache enthält einen Standardverbindungspool zum Verwalten von HTTP-Verbindungen. Wir können seine beiden Parameter MaxIdleConns und MaxIdleConnsPerHost verwenden, um die maximale Anzahl inaktiver Verbindungen und die maximale Anzahl inaktiver Hostverbindungen anzugeben. Wenn diese Leerlaufzahl erreicht ist, schließt Transport automatisch überschüssige Verbindungen. Der Code lautet wie folgt:

• package main
  import (
      "net/http"
      "io/ioutil"
      "fmt"
      "log"
  )
  func main() {
      transport := &http.Transport{
          MaxIdleConns:          10, // 最大空闲连接数
          MaxIdleConnsPerHost:   3,  // 每个域名地址最大空闲连接数
      }
      client := &http.Client{Transport: transport}
      req, err := http.NewRequest("GET", "http://www.baidu.com", nil)
      if err != nil {
          log.Fatal(err)
      }
      resp, err := client.Do(req)
      if err != nil {
          log.Fatal(err)
      }
      defer resp.Body.Close()
      body, err := ioutil.ReadAll(resp.Body)
      if err != nil {
          log.Fatal(err)
      }
      fmt.Println(string(body)[:50])
  }

HTTP-Server

Im HTTP-Server wird die Verbindungsverwaltung normalerweise automatisch vom verwaltet Server. Wir müssen nur den Server erstellen und ihn schließen, wenn die Verbindung nicht mehr benötigt wird. Normalerweise schließt der Server die Verbindung automatisch, nachdem eine Anfrage bearbeitet wurde. Es gibt jedoch mehrere Sondersituationen, in denen wir das Schließen der Verbindung manuell steuern müssen:

Verwenden Sie conn.Close() in einem HTTP-Prozessor, um die Verbindung zu schließen: wenn der Prozessor die verarbeitet HTTP-Anfrage: Wenn der Prozessor die Verbindung schließen muss, kann er die Verbindung mit der Methode conn.Close () schließen. Der Code lautet wie folgt:

• package main
  import (
      "fmt"
      "net/http"
  )
  func handler(w http.ResponseWriter, req *http.Request) {
      // 需要关闭连接时，使用conn.Close()
      conn, _, _ := w.(http.Hijacker).Hijack()
      conn.Close()
  }
  func main() {
      http.HandleFunc("/", handler)
      http.ListenAndServe(":8080", nil)
  }

Verwendung von Keep-Alive: Bei Verwendung von Keep-Alive wird der Lebenszyklus der Verbindung vom Server verwaltet. Der Server kann eine Keep-Alive-Zeit definieren, um zu steuern, wie lange die Verbindung nach dem Leerlauf geschlossen bleiben soll. Diese Zeit wird normalerweise im HTTP-Header festgelegt. Der Code lautet wie folgt:

• package main
  import (
      "log"
      "net/http"
  )
  func handler(w http.ResponseWriter, req *http.Request) {
      w.Header().Set("Connection", "keep-alive") // 定义keep-alive时间
      w.Write([]byte("hello world"))
  }
  func main() {
      http.HandleFunc("/", handler)
      log.Fatal(http.ListenAndServe(":8080", nil))
  }

2. Recycling-Mechanismus der HTTP-Verbindung

Wenn die Verbindung aufgebraucht ist, müssen wir Ressourcen für die Verbindung recyceln Verhindern Sie Ressourcenlecks und Leistungsprobleme wie einen Rückgang. Der Recyclingmechanismus von HTTP-Verbindungsressourcen muss normalerweise die folgenden Probleme berücksichtigen:

Maximale Lebensdauer langer HTTP-Verbindungen: Nachdem die Verbindung eine Zeit lang inaktiv war, wird der Server sofort aktiviert Stellen Sie die Verbindung wieder her. Diese Zeit kann vom Server festgelegt werden. Legen Sie einfach das Verbindungszeitlimit fest, wenn Sie das Serverobjekt erstellen.

• Maximale Anzahl von HTTP-Verbindungen: Die maximale Anzahl von Verbindungen, die innerhalb eines Zeitraums im Verbindungspool zulässig sind. Wenn der Verbindungspool die Verbindungspoolgröße überschreitet, werden sie automatisch geschlossen.
• Mechanismus zur Wiederverwendung von HTTP-Verbindungen: Die Wiederverwendung von Verbindungen bedeutet, dass mehrere Anforderungen gleichzeitig eine Verbindung gemeinsam nutzen. Dadurch kann unnötiger Ressourcenverbrauch bei langen Wartezuständen reduziert werden. Es ist jedoch zu beachten, dass ein kurzes Verbindungszeitlimit dazu führen kann, dass eine Anfrage mit vorübergehenden Netzwerkschwankungen fehlschlägt und somit die Stabilität des Systems beeinträchtigt wird.
3. Verwaltung des HTTP-Verbindungspools

In großen und stark gleichzeitigen Systemen müssen wir Verbindungspools verwenden, um HTTP-Verbindungen zu verwalten und die Systemleistung und -stabilität zu verbessern . Bei einer HTTP-Anfrage kann der Verbindungspool eine inaktive Netzwerkverbindung bereitstellen, um den Aufwand durch häufiges Erstellen und Zerstören von Verbindungen zu vermeiden. Verbindungspools werden normalerweise mithilfe regulärer Warteschlangen verwaltet, um sicherzustellen, dass die Elemente, die zuerst in die Warteschlange gelangen, zuerst verwendet werden, d. h. eine FIFO-Warteschlange. Im Folgenden finden Sie den Code zum Implementieren eines HTTP-Verbindungspools mithilfe der Go-Sprache:

package main
import (
    "fmt"
    "log"
    "net/http"
    "sync"
    "time"
)
type MyHttpClient struct {
    client    *http.Client     // http客户端对象
    Transport *http.Transport  // transport对象，用于管理http连接池
}
var once sync.Once
var myClient *MyHttpClient
func GetMyHttpClient() *MyHttpClient {
    once.Do(func() {
        myClient = &MyHttpClient{
            Transport: &http.Transport{
                Dial: func(network, addr string) (net.Conn, error) {
                    conn, err := net.DialTimeout(network, addr, 10*time.Second)
                    if err != nil {
                        return nil, err
                    }
                    return conn, nil
                },
                MaxIdleConns:          100,               // 连接池中最多拥有的连接数
                MaxIdleConnsPerHost:   2,                 // 每个域名最多拥有的连接数
                IdleConnTimeout:       60 * time.Second,  // 连接在闲置多久后被关闭
                TLSHandshakeTimeout:   10 * time.Second,  // TLS握手时限
                ExpectContinueTimeout: 1 * time.Second,   // 100-continue超时时限
            },
            client: &http.Client{},
        }
    })
    return myClient
}
func main() {
    client := GetMyHttpClient().client
    req, err := http.NewRequest("GET", "http://www.baidu.com", nil)
    if err != nil {
        log.Fatal(err)
    }
    defer client.CloseIdleConnections()
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(body)[:50])
}

4. Zusammenfassung

Die Kontrolle und Wiederverwendung von HTTP-Verbindungen ist ein wichtiger Punkt zur Leistungsoptimierung. In Golang können wir HTTP-Verbindungen durch manuelle Steuerung, Parametereinstellungen mithilfe der Transportklasse und Verbindungspooling verwalten, um die Systemleistung und -stabilität zu verbessern. Darüber hinaus müssen wir auch Probleme wie den Verbindungsrecyclingmechanismus und die Verwaltung des HTTP-Verbindungspools berücksichtigen und das System warten und optimieren.

Das obige ist der detaillierte Inhalt vonGolang http-Verbindung schließen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!