Go Academy · Lektion

Verbindungsverwaltung

Verbindungsabbrüche behandeln

Verbindungsverwaltung ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Verbindungen halten nicht ewig

Clients schließen Tabs, verlieren die WLAN-Verbindung oder stürzen ab. Robuste WebSocket-Server müssen Verbindungsabbrüche erkennen, Ressourcen aufräumen und Goroutinen beenden. Andernfalls entstehen Speicher- und Socket-Leaks.

Der Close-Handshake

Ein sauberer Verbindungsabbau sendet in beide Richtungen einen Close-Frame. gorilla stellt dies als Fehler von ReadMessage dar, dessen Close-Code Sie untersuchen können.

if websocket.IsCloseError(err, websocket.CloseNormalClosure) {
    // graceful close
}

Ping/Pong-Keepalive

Um eine halb offene Verbindung zu erkennen (die Gegenstelle ist verschwunden, ohne zu schließen), sendet der Server regelmäßig Ping-Steuerframes und erwartet Pong-Antworten.

conn.SetPongHandler(func(string) error {
    conn.SetReadDeadline(time.Now().Add(60 * time.Second))
    return nil
})

Lese-Deadlines

Setzen Sie eine Lese-Deadline, damit ein nicht mehr erreichbarer Peer schließlich einen Fehler verursacht, statt für immer zu blockieren. Erneuern Sie die Deadline, sobald ein Pong eintrifft.

conn.SetReadDeadline(time.Now().Add(60 * time.Second))

Der Ping-Ticker

Ein Ticker in der Writer-Goroutine löst regelmäßig Pings aus. Wenn ein Schreibvorgang fehlschlägt, ist die Verbindung tot und Sie beenden die Goroutine.

ticker := time.NewTicker(54 * time.Second)
defer ticker.Stop()
for range ticker.C {
    if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
        return
    }
}

Aufräumen beim Beenden

Wenn eine Lese- oder Schreibschleife endet, melden Sie den Client ab und schließen Sie die Verbindung. defer macht dies auch bei einer Panic zuverlässig.

defer func() {
    hub.unregister <- client
    conn.Close()
}()

Zwei Goroutinen pro Verbindung

Das Standardmuster verwendet pro Verbindung einen readPump und einen writePump. Wenn eine der beiden Goroutinen einen Fehler erkennt, löst sie das Aufräumen aus, wodurch die andere beendet wird (oft durch Schließen des Sendekanals).

Auch Schreib-Deadlines

Setzen Sie Schreib-Deadlines, damit ein blockierter Schreibvorgang eine Goroutine nicht für immer festhält. Ein abgelaufener Schreibvorgang gibt einen Fehler zurück, woraufhin Sie die Verbindung abbauen.

conn.SetWriteDeadline(time.Now().Add(10 * time.Second))

Sauberes Herunterfahren des Servers

Senden Sie beim Herunterfahren des Servers jedem Client einen Close-Frame und warten Sie kurz. Kombinieren Sie dies mit http.Server.Shutdown und einer Deadline für den Context.

conn.WriteMessage(websocket.CloseMessage,
    websocket.FormatCloseMessage(websocket.CloseGoingAway, "bye"))

Auf dem Client erneut verbinden

Verbindungsabbrüche sind normal. Clients sollten eine Wiederverbindungslogik mit exponentiellem Backoff implementieren. Die Serverseite muss lediglich jede Verbindung und Trennung sauber behandeln.

Ausführbar: Analogie zur Timeout-Erkennung

WebSocket-Keepalive benötigt die Bibliothek. Dieses Programm aus der Standardbibliothek bildet eine auf einer Deadline basierende Erreichbarkeitsprüfung mit einem Timer und einem Kanal nach.

package main

import (
    "fmt"
    "time"
)

func main() {
    pong := make(chan struct{})
    go func() {
        time.Sleep(20 * time.Millisecond) // simulate a slow/absent peer
        _ = pong                          // no pong sent -> dead connection
    }()
    select {
    case <-pong:
        fmt.Println("alive")
    case <-time.After(10 * time.Millisecond):
        fmt.Println("no pong: closing dead connection")
    }
}

Kurztest

Testen Sie Ihr Verständnis der Verbindungsverwaltung.

Zusammenfassung

Sie haben die Verbindungsverwaltung gelernt:

Behandeln Sie den Close-Handshake und untersuchen Sie Close-Codes
Verwenden Sie Ping/Pong sowie Lese- und Schreib-Deadlines, um nicht mehr erreichbare Peers zu erkennen
Führen Sie Lese- und Schreib-Pumps aus; räumen Sie mit defer auf
Fahren Sie mit Close-Frames sauber herunter; Clients verbinden sich mit Backoff erneut

Häufig gestellte Fragen

Ist die Lektion „Verbindungsverwaltung“ kostenlos?

Ja — der vollständige Text von „Verbindungsverwaltung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Verbindungsverwaltung“?

Verbindungsabbrüche behandeln Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Verbindungsverwaltung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Go Academy