Comment parvenir à bloquer les opérations de lecture TCP en Go ?

TCP Read in Go : plongée dans les opérations bloquantes et non bloquantes

En Go, la méthode Read pour les connexions TCP fonctionne de manière non -manière de blocage. Cela implique que l'opération de lecture reviendra immédiatement, même si les données complètes ne sont pas disponibles. Cela peut poser des problèmes lorsque vous tentez de lire des quantités spécifiques de données ou lorsque vous utilisez des protocoles qui nécessitent des transferts de données synchronisés.

Pourquoi la lecture TCP est-elle non bloquante ?

Réseau les protocoles de communication, tels que TCP, traitent intrinsèquement les données de manière semblable à un flux. Cela signifie que les données peuvent être transmises et reçues en morceaux, et qu'il n'y a aucune frontière inhérente qui délimite la fin d'un seul paquet de données.

Comment obtenir le blocage de la lecture en Go

Bien que la méthode Read soit non bloquante, il existe des techniques pour obtenir un comportement de type bloquant :

• io.ReadAtLeast : Cette méthode lit un nombre minimum d'octets de la connexion. Si la connexion ne fournit pas suffisamment de données immédiatement, la méthode se bloquera jusqu'à ce que les données demandées soient reçues.
• io.ReadFull : Cette méthode lit exactement le nombre d'octets spécifié de la connexion. Si la connexion ne fournit pas suffisamment de données immédiatement, la méthode se bloquera jusqu'à ce que la totalité des données soit reçue.

Gestion des lectures partielles

Dans les cas où le montant des données reçues de la méthode Read est inférieure à celle attendue, il est crucial de déterminer le traitement approprié pour les lectures partielles. Les protocoles utilisent souvent des délimiteurs ou d'autres mécanismes pour indiquer la fin d'un paquet de données ou d'un message.

Exemple de code avec gestion des erreurs

Dans les extraits de code fournis, la méthode Read n’est pas correctement utilisé. Le code doit être modifié pour tenir compte des lectures partielles et gérer les erreurs :

<code class="go">// Server Code
package main

import (
    "fmt"
    "log"
    "net"
)

func main() {
    listener, err := net.ListenTCP("tcp", &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 4243})
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()
    for {
        conn, err := listener.AcceptTCP()
        if err != nil {
            log.Fatal(err)
        }
        conn.SetNoDelay(false)
        data := make([]byte, 512)
        for {
            n, err := conn.Read(data)
            if err != nil {
                fmt.Println(err)
                break
            }
            fmt.Println(data[:n])
        }
    }
}</code>

<code class="go">// Client Code
package main

import (
    "log"
    "net"
)

func main() {
    conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 4243})
    if err != nil {
        log.Fatal(err)
    }
    conn.SetNoDelay(false)
    conn.Write([]byte("Hello World"))
}</code>

N'oubliez pas de vérifier systématiquement les erreurs dans tout votre code pour vous assurer que tout problème potentiel est rapidement identifié et traité.

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!