Comment puis-je bloquer les lectures TCP dans Go ?

Lectures TCP bloquantes ou non bloquantes dans Go

Lorsque vous travaillez avec des connexions TCP dans Go, l'opération de lecture est généralement non bloquante. Cela signifie que la fonction Read revient immédiatement, même si les données ne sont pas encore disponibles. Cependant, dans certains cas, il peut être souhaitable d'avoir une opération de lecture bloquante qui attend la réception des données.

Est-il possible d'activer le blocage des lectures dans Go ?

Bien que la fonction de lecture intégrée ne soit pas bloquante, Go ne fournit pas de moyen direct de bloquer les lectures. Cependant, plusieurs méthodes peuvent simuler un comportement de blocage :

• Utilisation de io.ReadAtLeast() : Cette fonction bloque jusqu'à ce que le nombre d'octets spécifié ait été lu. Cependant, cela peut ne pas être fiable si plus de données arrivent que prévu.
• Lecture en boucle : Un moyen simple de simuler des lectures bloquantes consiste à appeler à plusieurs reprises la fonction Read dans une boucle jusqu'à ce que les données soient disponible. Cette approche est plus fiable mais peut consommer des ressources CPU supplémentaires.
• Utilisation d'un canal : Une autre option consiste à utiliser un canal pour mettre les données en mémoire tampon. Le client enverra des données au canal et les bloquera jusqu'à ce qu'elles soient reçues par le serveur.

Exemple de code pour une lecture de blocage simulé

Voici un exemple de simuler une lecture bloquante à l'aide d'une boucle :

<code class="go">func init_tcp() *net.TCPListener {
    laddr, err := net.ResolveTCPAddr("tcp", ":4243")
    if err != nil {
            log.Fatal(err)
    }
    tcp, err := net.ListenTCP("tcp", laddr)
    if err != nil {
            log.Fatal(err)
    }
    return tcp
}

func main() {
    tcp := init_tcp()
    conn, _ := tcp.Accept()
    data := make([]byte, 512)
    conn.SetNoDelay(false)
    for {
            // Repeat Read() until data is available
            for len(data) == 0 {
                    conn.Read(data)
            }
            fmt.Println(data)
            // Reset data for next iteration
            data = make([]byte, 512)
    }
}</code>

Conclusion

Bien que les lectures TCP de Go soient non bloquantes par défaut, il est possible de simuler un comportement de blocage à l'aide de divers techniques. La meilleure approche dépend des exigences spécifiques de l’application. Gardez à l’esprit que le blocage simulé peut introduire une surcharge ou une complexité supplémentaire, il doit donc être utilisé judicieusement.

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!