golang http fermer la connexion

Lorsque nous utilisons Golang pour la programmation HTTP, nous devons souvent réfléchir à la manière de fermer la connexion. La fermeture des connexions peut efficacement éviter le gaspillage de ressources, améliorer les performances et réduire les problèmes inutiles causés par des problèmes de réseau. Cet article présentera en détail comment fermer les connexions HTTP dans Golang et analysera certains détails.

1. Comment fermer les connexions HTTP

Le client et le serveur HTTP dans le langage Go implémentent une série de processus sous-jacents pour gérer les connexions HTTP. Ces traitements de bas niveau ne sont généralement pas exposés à l'utilisateur, mais sont cachés dans l'implémentation interne par les clients et serveurs HTTP. Alors comment fermer la connexion dans le client et le serveur HTTP ?

1. Client HTTP

Dans le client HTTP, nous avons plusieurs façons de fermer la connexion :

• Utilisez le mot-clé defer pour fermer manuellement la connexion : Une fois que le client a appelé l'interface, la connexion est généralement fermée automatiquement. Mais si le client actuel doit demander l'interface plusieurs fois, vous pouvez envisager de contrôler manuellement la fermeture de la connexion et d'utiliser defer pour retarder la fermeture de la connexion. Le code est le suivant :

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])
}

• Utilisez MaxIdleConns ou MaxIdleConnsPerHost de la classe Transport. contrôler la limite supérieure des connexions dans le pool de connexions : Langue Go Le http.Transport contient le pool de connexions par défaut pour la gestion des connexions HTTP. Nous pouvons utiliser ses deux paramètres MaxIdleConns et MaxIdleConnsPerHost pour spécifier le nombre maximum de connexions inactives et le nombre maximum de connexions hôtes inactives. Lorsque ce nombre inactif est atteint, Transport fermera automatiquement les connexions excédentaires. Le code est le suivant :

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])
}

2. Serveur HTTP

Dans le serveur HTTP, la gestion des connexions est généralement gérée automatiquement par le serveur. Il suffit de créer le serveur et de le fermer lorsque la connexion n'est plus nécessaire. Normalement, le serveur ferme automatiquement la connexion après avoir traité une requête. Mais il existe plusieurs situations particulières qui nous obligent à contrôler manuellement la fermeture de la connexion :

• Utilisez conn.Close() dans un processeur HTTP pour fermer la connexion : Lorsque le processeur traite la requête HTTP, si le processeur doit fermer la connexion, puis une connexion peut être fermée à l'aide de la méthode conn.Close(). Le code est le suivant :

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)
}

• Utilisation de Keep-Alive : Lors de l'utilisation de Keep-Alive, le cycle de vie de la connexion est géré par le serveur. Le serveur peut définir une durée de conservation pour contrôler la durée pendant laquelle la connexion doit être fermée après avoir été inactive. Cette heure est généralement définie dans l'en-tête HTTP. Le code est le suivant :

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. Mécanisme de recyclage de la connexion HTTP

Lorsque la connexion est épuisée, nous devons recycler les ressources de la connexion afin d'éviter les fuites de ressources, la dégradation des performances et d'autres problèmes. Le mécanisme de recyclage des ressources de connexion HTTP doit généralement prendre en compte les problèmes suivants :

• Durée de vie maximale des connexions HTTP longues : après que la connexion est restée inactive pendant un certain temps, le serveur recyclera immédiatement la connexion. Cette durée peut être déterminée par le serveur. Il suffit de définir le délai d'expiration de la connexion lors de la création de l'objet serveur.
• Nombre maximum de connexions HTTP : le nombre maximum de connexions autorisées dans le pool de connexions sur une période donnée. Lorsque le pool de connexions dépasse la taille du pool de connexions, ils seront automatiquement fermés.
• Mécanisme de réutilisation des connexions HTTP : la réutilisation des connexions signifie que plusieurs requêtes partagent une connexion en même temps. Cela peut réduire l’utilisation inutile des ressources lors de longs états d’attente. Cependant, il convient de noter que si le délai d'expiration de la connexion est court, cela peut entraîner l'échec d'une requête présentant des fluctuations transitoires du réseau, affectant ainsi la stabilité du système.

3. Gestion du pool de connexions HTTP

Dans les systèmes volumineux et hautement simultanés, nous devons utiliser des pools de connexions pour gérer les connexions HTTP afin d'améliorer les performances et la stabilité du système. Lors de l'appel d'une requête HTTP, le pool de connexions peut fournir une connexion réseau inactive pour éviter la surcharge liée à la création et à la destruction fréquentes de connexions. Les pools de connexions sont généralement gérés à l'aide de files d'attente régulières pour garantir que les éléments qui entrent en premier dans la file d'attente sont utilisés en premier, c'est-à-dire une file d'attente FIFO. Voici le code pour implémenter le pool de connexions HTTP en utilisant le langage Go :

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. Résumé

Le contrôle et le recyclage des connexions HTTP est un point clé d'optimisation des performances. Dans Golang, nous pouvons gérer les connexions HTTP via un contrôle manuel, des paramètres à l'aide de la classe Transport et un regroupement de connexions pour améliorer les performances et la stabilité du système. En outre, nous devons également prendre en compte des problèmes tels que le mécanisme de recyclage des connexions et la gestion du pool de connexions HTTP, ainsi que maintenir et optimiser le système.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!