Go net/http Interna: TCP Socket Verwaltung

Vorwort

Bevor wir beginnen, wollen wir kurz zwei Konzepte, Socket und File Descriptor, erklären, um das spätere Verständnis zu erleichtern.

Was ist ein Socket?

Ein Socket ist eine grundlegende Abstraktion für die Netzwerkkommunikation. Er bietet eine Standardschnittstelle für Anwendungen, um auf den Netzwerkprotokollstack zuzugreifen. Einfach ausgedrückt, ein Socket ist ein Endpunkt für die Netzwerkkommunikation, der es Programmen auf verschiedenen Computern ermöglicht, Daten über das Netzwerk auszutauschen.

Hauptmerkmale von Socket:

Er fungiert als Schnittstelle zwischen der Anwendungsschicht und der Transportschicht.
Er kann als eine spezielle Art von Datei betrachtet werden, die Lese- und Schreiboperationen unterstützt.
Es gibt verschiedene Typen: TCP Socket (verbindungsorientiert), UDP Socket (verbindungslos) usw.

Was ist ein File Descriptor?

Ein File Descriptor ist ein ganzzahliger Wert, der vom Betriebssystem verwendet wird, um offene Dateien zu identifizieren und zu verwalten. In Unix/Linux-Systemen ist alles eine Datei, einschließlich regulärer Dateien, Verzeichnisse, Geräte und sogar Netzwerkverbindungen.

Wichtige Punkte zu File Descriptors:

Es ist eine nicht-negative ganze Zahl, die normalerweise bei 0 beginnt (0 ist die Standardeingabe, 1 ist die Standardausgabe, 2 ist die Standardfehlerausgabe).
Im OS-Kernel ist der File Descriptor ein Index, der auf einen Dateitabelleneintrag zeigt.
Jeder Prozess hat seine eigene File Descriptor-Tabelle.

Beziehung zwischen Socket und File Descriptor

In Unix/Linux-Systemen werden Sockets auch als eine spezielle Art von Datei betrachtet und haben daher auch entsprechende File Descriptors. Wenn Sie einen Socket erstellen:

Das Betriebssystem weist einen File Descriptor zu.
Dieser File Descriptor kann für nachfolgende Netzwerkoperationen verwendet werden (lesen, schreiben, schliessen usw.).
Anwendungen interagieren über diesen File Descriptor mit dem Socket.

TCP-Verbindungsaufbauprozess

Socket-Erstellung

// Interne Implementierung des Net-Pakets
fd, err := socket(family, syscall.SOCK_STREAM, syscall.IPPROTO_TCP)

Dieser Schritt erstellt einen Socket-File-Deskriptor durch einen Systemaufruf.

Server Bind und Listen

// Vereinfachter Server-Code-Flow
bind(fd, addr)
listen(fd, backlog)

Der Server bindet den Socket an eine bestimmte Adresse und einen bestimmten Port und beginnt dann, auf Verbindungsanfragen zu warten.

Verbindungen annehmen

// Vereinfachte Version von net/http/server.go
func (srv *Server) Serve(l net.Listener) error {
    for {
        rw, err := l.Accept()  // Eine neue Verbindung annehmen
        if err != nil {
            // Fehler behandeln
            continue
        }
        go srv.newConn(rw).serve(ctx)  // Eine neue Goroutine für jede Verbindung erstellen
    }
}

Client Connect

// Vereinfachte Version von net/http/transport.go
func (t *Transport) dialConn(ctx context.Context, addr string) (*conn, error) {
    // TCP-Verbindung erstellen
    netConn, err := t.dial(ctx, "tcp", addr)
    if err != nil {
        return nil, err
    }
    // Als HTTP-Verbindung wrappen
    return &conn{
        conn: netConn,
        // ... andere Felder
    }, nil
}

Datenübertragung

// Daten lesen
n, err := syscall.Read(fd, buf)
// Daten schreiben
n, err := syscall.Write(fd, data)

Schliessen der Verbindung

err := syscall.Close(fd)

Wichtige Implementierungsdetails

Multiplexing

HTTP/1.1 verwendet den Keep-Alive-Mechanismus, um TCP-Verbindungen wiederzuverwenden.
HTTP/2 implementiert Multiplexing durch Streams, wodurch mehrere HTTP-Anfragen eine einzelne TCP-Verbindung gemeinsam nutzen können.

Connection Pool Management

// net/http/transport.go
type Transport struct {
    // Leerlauf-Verbindungspool
    idleConn     map[connectMethodKey][]*persistConn
    // Maximale Anzahl von Leerlaufverbindungen
    maxIdleConns int
    // ... andere Felder
}

Timeout Control

// Verbindungstimeout setzen
conn.SetDeadline(time.Now().Add(timeout))

Fehlerbehandlung und Wiederholungsmechanismus

// Vereinfachte Wiederholungslogik
for retry := 0; retry < maxRetries; retry++ {
    conn, err := dial()
    if err == nil {
        return conn
    }
    // Vor dem Wiederholungsversuch warten
    time.Sleep(backoff)
}

Workflow

Wenn der Client eine HTTP-Anfrage initiiert:

Zuerst prüfen, ob eine verfügbare Verbindung im Verbindungspool vorhanden ist.
Wenn nicht, eine neue TCP-Verbindung erstellen.
Die HTTP-Anfragedaten senden.
Auf die Antwort warten und diese lesen.

Wenn der Server eine Anfrage bearbeitet:

Die Accept-Schleife akzeptiert neue Verbindungen.
Für jede Verbindung wird eine Goroutine erstellt.
Die HTTP-Anfrage wird geparst.
Die Anfrage wird verarbeitet und eine Antwort zurückgegeben.

Dies ist der Kernmechanismus, mit dem das net/http-Paket HTTP-Verbindungen auf dem TCP-Protokoll implementiert. Durch Abstraktion und Kapselung müssen Entwickler sich nicht direkt mit Low-Level-TCP-Verbindungsdetails befassen und profitieren gleichzeitig von effizienten Verbindungsverwaltungs- und Wiederverwendungsmechanismen.