Golang TCP ne se déconnecte jamais

Dans Golang, TCP se déconnectera par défaut après avoir établi une connexion. En effet, le protocole TCP lui-même doit assurer la fiabilité de la connexion. Une fois la connexion déconnectée, une nouvelle connexion sera rétablie. Mais il existe également des situations dans lesquelles nous espérons que la connexion TCP ne sera pas déconnectée. Par exemple, dans des situations de concurrence élevée, l'établissement fréquent de connexions exercera une pression supplémentaire sur le serveur. Alors comment s'assurer que Golang TCP n'est pas déconnecté ?

1. TCP Keep-Alive

TCP Keep-Alive est un mécanisme fourni par le protocole TCP pour détecter si la connexion est toujours active. Lorsqu'une connexion TCP ne transmet pas de données pendant un certain temps, le mécanisme Keep-Alive enverra des paquets de détection spécifiques au homologue pour savoir si la connexion existe toujours. Si l'homologue ne répond pas au paquet de sonde, il sera considéré que l'homologue s'est déconnecté et la connexion sera activement fermée. Si l'homologue peut répondre au paquet de sonde, la connexion existe toujours. Nous pouvons utiliser le mécanisme TCP Keep-Alive pour obtenir la non-déconnexion de Golang TCP.

1.1 Activer TCP Keep-Alive

Pour activer TCP Keep-Alive, nous devons définir les propriétés du socket. Golang peut utiliser la structure TCPConn dans le package net pour représenter une connexion TCP. TCPConn fournit de nombreuses méthodes pour exploiter les connexions TCP. Parmi eux, la méthode SetKeepAlive peut être utilisée pour définir TCP Keep-Alive.

L'exemple de code est le suivant :

conn, err := net.Dial("tcp", "127.0.0.1:8080")
if err != nil {
    fmt.Println("dial error:", err)
    return
}
tcpConn := conn.(*net.TCPConn)
// 设置为开启 TCP KeepAlive，默认为不开启
tcpConn.SetKeepAlive(true)

1.2 Définir les paramètres TCP Keep-Alive

TCP Keep-Alive a trois paramètres, nous pouvons définir via la méthode TCPConn pour définir ces paramètres. Il s'agit de KeepAlive, KeepAlivePeriod et KeepAliveCount.

• KeepAlive : indique s'il faut activer TCP Keep-Alive. La valeur par défaut n'est pas activée.
• KeepAlivePeriod : Indique l'intervalle de temps d'envoi des paquets de détection. La valeur par défaut n'est pas définie et est déterminée par le système d'exploitation.
• KeepAliveCount : Indique le nombre de fois que le paquet de détection est envoyé. La valeur par défaut n'est pas définie et est déterminée par le système d'exploitation.

Nous pouvons paramétrer ces trois paramètres en fonction des besoins réels.

L'exemple de code est le suivant :

tcpConn.SetKeepAlive(true)          // 开启 TCP Keep-Alive
tcpConn.SetKeepAlivePeriod(time.Duration(30) * time.Second) // 设置探测包发送时间间隔为 30 秒
tcpConn.SetKeepAliveCount(3)        // 设置探测包的发送次数为 3

1.3 Fréquence d'envoi des paquets de détection Keep-Alive

Par défaut, l'envoi des paquets de détection Keep-Alive la fréquence est contrôlée par le système qui décide. Dans la plupart des systèmes d'exploitation, les paquets de sonde TCP Keep-Alive sont envoyés toutes les 2 heures. Si la fréquence doit être modifiée, cela peut être réalisé en modifiant les paramètres du système d'exploitation. Dans le système d'exploitation Linux, vous pouvez modifier la fréquence d'envoi des paquets de détection TCP Keep-Alive en modifiant les paramètres du système de fichiers proc.

2. Utilisez des connexions longues

Une autre façon d'obtenir la non-déconnexion de Golang TCP est d'utiliser des connexions longues. Une connexion longue fait référence à une connexion ininterrompue entre le client et le serveur. En mode de connexion longue, une fois que le client a établi une connexion avec le serveur, le client peut envoyer une demande à tout moment et le serveur peut également envoyer une réponse à tout moment. Cela peut réduire la surcharge liée à l'établissement fréquent de connexions et améliorer les performances du serveur.

Concernant la façon d'implémenter des connexions longues, voici un exemple de code simple pour référence.

package main

import (
    "bufio"
    "fmt"
    "net"
)

func main() {
    listen, err := net.Listen("tcp", ":8080")
    if err != nil {
        panic(err)
    }

    for {
        conn, err := listen.Accept()
        if err != nil {
            continue
        }
        go handle(conn)
    }
}

func handle(conn net.Conn) {
    defer conn.Close()

    reader := bufio.NewReader(conn)
    for {
        data, err := reader.ReadString('
')
        if err != nil {
            return
        }

        response := fmt.Sprintf("echo: %s", data)
        conn.Write([]byte(response))
    }
}

Dans l'exemple de code ci-dessus, nous acceptons la demande du client en démarrant un service TCP. Lorsque le client établit une connexion avec le serveur, le serveur reçoit la demande du client via une boucle et renvoie une réponse. Étant donné que la connexion entre le serveur et le client ne sera pas activement déconnectée, le client peut envoyer des requêtes au serveur à tout moment.

3. Résumé

Cet article présente deux méthodes pour obtenir la non-déconnexion de Golang TCP, à savoir l'utilisation du mécanisme TCP Keep-Alive et l'utilisation de connexions longues. Dans le développement réel, vous devez choisir une méthode qui vous convient en fonction de la situation réelle. Si vous n'utilisez que de manière légère les connexions TCP, il est recommandé d'utiliser TCP Keep-Alive ; si vous devez envoyer des requêtes fréquemment, il est recommandé d'utiliser des connexions longues. Quelle que soit la méthode utilisée, dans les applications réelles, il faut veiller à normaliser et à protéger la sécurité de la connexion afin d'éviter les failles de sécurité.

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!