Go Academy · Lezione

Gestione delle connessioni

Gestire le disconnessioni

Gestione delle connessioni è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

Le connessioni non durano per sempre

I client chiudono le schede, perdono la connessione Wi-Fi o si arrestano in modo anomalo. I server WebSocket robusti devono rilevare le disconnessioni, liberare le risorse e terminare le goroutine. In caso contrario, si verificano perdite di memoria e socket.

L'handshake di chiusura

Un arresto ordinato invia un frame di chiusura in entrambe le direzioni. gorilla lo espone come un errore restituito da ReadMessage, con un codice di chiusura che è possibile esaminare.

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

Keepalive Ping/Pong

Per rilevare una connessione semiaperta (quando l'interlocutore scompare senza chiudere), il server invia periodicamente frame di controllo ping e attende le risposte pong.

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

Deadline di lettura

Imposti una deadline di lettura, in modo che un interlocutore non più attivo generi prima o poi un errore invece di bloccarsi per sempre. La rinnovi ogni volta che arriva un pong.

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

Il ticker dei ping

Un ticker nella goroutine di scrittura invia ping periodici. Se una scrittura non riesce, la connessione è inattiva e la goroutine termina.

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

Pulizia all'uscita

Quando termina un ciclo di lettura o scrittura, annulli la registrazione del client e chiuda la connessione. defer rende questa operazione affidabile anche in caso di panic.

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

Due goroutine per connessione

Il modello standard esegue un readPump e un writePump per ogni connessione. Quando uno dei due rileva un errore, avvia la pulizia che arresta l'altro, spesso chiudendo il canale send.

Anche deadline di scrittura

Imposti delle deadline di scrittura, in modo che una scrittura bloccata non mantenga una goroutine in attesa per sempre. Una scrittura la cui deadline è scaduta restituisce un errore e la connessione viene terminata.

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

Arresto graduale del server

Durante l'arresto del server, invii a ogni client un frame di chiusura e attenda brevemente. Combini questa operazione con http.Server.Shutdown e una deadline del context.

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

Riconnessione lato client

Le disconnessioni sono normali. I client dovrebbero implementare una logica di riconnessione con backoff esponenziale. Sul lato server è sufficiente gestire correttamente ogni connessione e disconnessione.

Eseguibile: analogia del rilevamento dei timeout

Il keepalive dei WebSocket richiede la libreria; questo programma basato sulla libreria standard modella un controllo di attività basato su una deadline, utilizzando un timer e un canale.

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

Verifica rapida

Verifichi la propria comprensione della gestione delle connessioni.

Riepilogo

Ha appreso la gestione delle connessioni:

Gestisca l'handshake di chiusura ed esamini i codici di chiusura
Utilizzi ping/pong insieme alle deadline di lettura e scrittura per rilevare gli interlocutori inattivi
Esegua i pump di lettura e scrittura; esegua la pulizia con defer
Arresti il server gradualmente con frame di chiusura; i client si riconnettono con backoff

Domande Frequenti

La lezione «Gestione delle connessioni» è gratuita?

Sì — il testo completo di «Gestione delle connessioni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «Gestione delle connessioni»?

Gestire le disconnessioni Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Gestione delle connessioni»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Go Academy