Golang TCP trennt nie die Verbindung

In Golang wird TCP nach dem Herstellen einer Verbindung standardmäßig getrennt. Dies liegt daran, dass das TCP-Protokoll selbst die Zuverlässigkeit der Verbindung gewährleisten muss. Sobald die Verbindung getrennt wird, wird eine neue Verbindung hergestellt. Es gibt jedoch auch Situationen, in denen wir hoffen, dass die TCP-Verbindung nicht getrennt wird. Beispielsweise wird in Situationen mit hoher Parallelität der häufige Verbindungsaufbau den Server zusätzlich belasten. Wie kann also sichergestellt werden, dass Golang TCP nicht getrennt wird?

1. TCP Keep-Alive

TCP Keep-Alive ist ein vom TCP-Protokoll bereitgestellter Mechanismus, um zu erkennen, ob die Verbindung noch aktiv ist. Wenn eine TCP-Verbindung über einen bestimmten Zeitraum keine Daten überträgt, sendet der Keep-Alive-Mechanismus einige spezifische Erkennungspakete an den Peer, um zu erfahren, ob die Verbindung noch besteht. Wenn der Peer nicht auf das Testpaket antwortet, wird davon ausgegangen, dass der Peer die Verbindung getrennt hat, und die Verbindung wird aktiv geschlossen. Wenn der Peer auf das Probe-Paket antworten kann, besteht die Verbindung weiterhin. Wir können den TCP-Keep-Alive-Mechanismus verwenden, um eine Nicht-Trennung der Golang-TCP-Verbindung zu erreichen.

1.1 TCP Keep-Alive aktivieren

Um TCP Keep-Alive zu aktivieren, müssen wir die Socket-Eigenschaften festlegen. Golang kann die TCPConn-Struktur im Netzpaket verwenden, um eine TCP-Verbindung darzustellen. TCPConn bietet viele Methoden zum Betreiben von TCP-Verbindungen. Unter anderem kann die SetKeepAlive-Methode zum Festlegen von TCP Keep-Alive verwendet werden.

Der Beispielcode lautet wie folgt:

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 TCP-Keep-Alive-Parameter festlegen

TCP Keep-Alive hat drei Parameter, die wir einstellen können sie über die TCPConn-Methode, um diese Parameter festzulegen. Dies sind KeepAlive, KeepAlivePeriod und KeepAliveCount.

• KeepAlive: Gibt an, ob TCP Keep-Alive aktiviert werden soll. Die Standardeinstellung ist nicht aktiviert.
• KeepAlivePeriod: Gibt das Zeitintervall für das Senden von Erkennungspaketen an. Der Standardwert ist nicht festgelegt und wird vom Betriebssystem bestimmt.
• KeepAliveCount: Gibt an, wie oft das Erkennungspaket gesendet wird. Der Standardwert ist nicht festgelegt und wird vom Betriebssystem bestimmt.

Wir können diese drei Parameter entsprechend den tatsächlichen Anforderungen einstellen.

Der Beispielcode lautet wie folgt:

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

1.3 Häufigkeit des Sendens von Keep-Alive-Erkennungspaketen

Standardmäßig wird das Keep-Alive-Erkennungspaket gesendet Die Frequenz wird vom System gesteuert. In den meisten Betriebssystemen werden TCP-Keep-Alive-Probepakete alle 2 Stunden gesendet. Wenn die Häufigkeit geändert werden muss, kann dies durch Ändern von Parametern im Betriebssystem erreicht werden. Im Linux-Betriebssystem können Sie die Häufigkeit des Sendens von TCP-Keep-Alive-Erkennungspaketen ändern, indem Sie die Parameter im Proc-Dateisystem ändern.

2. Verwenden Sie lange Verbindungen

Eine andere Möglichkeit, eine Nichtunterbrechung von Golang TCP zu erreichen, besteht darin, lange Verbindungen zu verwenden. Eine lange Verbindung bezieht sich auf eine ununterbrochene Verbindung zwischen dem Client und dem Server. Im langen Verbindungsmodus kann der Client jederzeit eine Anfrage senden, nachdem der Client eine Verbindung zum Server hergestellt hat, und der Server kann jederzeit auch eine Antwort senden. Dadurch kann der Overhead beim häufigen Verbindungsaufbau reduziert und die Serverleistung verbessert werden.

Zur Implementierung langer Verbindungen finden Sie hier einen einfachen Beispielcode als Referenz.

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

Im obigen Beispielcode akzeptieren wir die Anfrage des Clients, indem wir einen TCP-Dienst starten. Wenn der Client eine Verbindung mit dem Server herstellt, empfängt der Server die Anfrage des Clients über eine Schleife und gibt eine Antwort zurück. Da die Verbindung zwischen Server und Client nicht aktiv getrennt wird, kann der Client jederzeit Anfragen an den Server senden.

3. Zusammenfassung

In diesem Artikel werden zwei Methoden vorgestellt, um eine Nichtunterbrechung von Golang TCP zu erreichen, nämlich die Verwendung des TCP-Keep-Alive-Mechanismus und die Verwendung langer Verbindungen. In der tatsächlichen Entwicklung sollten Sie eine Methode wählen, die entsprechend der tatsächlichen Situation zu Ihnen passt. Wenn Sie TCP-Verbindungen nur selten nutzen, empfiehlt es sich, TCP Keep-Alive zu verwenden; wenn Sie häufig Anfragen senden müssen, empfiehlt es sich, lange Verbindungen zu verwenden. Unabhängig davon, welche Methode verwendet wird, muss in tatsächlichen Anwendungen auf die Standardisierung und den Schutz der Verbindungssicherheit geachtet werden, um Sicherheitslücken zu vermeiden.

Das obige ist der detaillierte Inhalt vonGolang TCP trennt nie die Verbindung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!