Go Academy · Leçon

Diffuser des messages

Envoyer des messages à plusieurs clients

Diffuser des messages est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Envoyer à plusieurs clients

Les salons de discussion et les flux en direct doivent envoyer un même message à chaque client connecté. Comme chaque WebSocket n'autorise qu'un seul écrivain, vous avez besoin d'un modèle de coordination : le concentrateur.

Le modèle du concentrateur

Un concentrateur est une gouroutine centrale qui possède l'ensemble des clients et un canal de diffusion. Les clients s'enregistrent, se désinscrivent et le concentrateur répartit les messages. Aucune map partagée n'est manipulée directement par plusieurs gouroutines.

Structures de données du concentrateur

Le concentrateur contient :

Un ensemble de clients (map[*Client]bool)
Un canal de messages broadcast
Les canaux register et unregister

type Hub struct {
    clients    map[*Client]bool
    broadcast  chan []byte
    register   chan *Client
    unregister chan *Client
}

Boucle d'exécution du concentrateur

Une seule gouroutine Run sélectionne les canaux. Comme cette gouroutine est la seule à modifier la map, aucun verrou n'est nécessaire.

func (h *Hub) Run() {
    for {
        select {
        case c := <-h.register:
            h.clients[c] = true
        case c := <-h.unregister:
            delete(h.clients, c)
            close(c.send)
        case msg := <-h.broadcast:
            for c := range h.clients {
                c.send <- msg
            }
        }
    }
}

Canal d'envoi par client

Chaque client possède un send chan []byte avec tampon. Le concentrateur y écrit ; une gouroutine d'écriture dédiée vide ce canal vers le socket. Cela respecte la règle du lecteur unique.

type Client struct {
    conn *websocket.Conn
    send chan []byte
}

La gouroutine d'écriture

Chaque client exécute une writePump qui parcourt send et écrit sur le socket. Si le canal se ferme, elle envoie une trame de fermeture.

func (c *Client) writePump() {
    for msg := range c.send {
        c.conn.WriteMessage(websocket.TextMessage, msg)
    }
}

Éviter les clients lents

Si un client est lent, son send avec tampon finit par être plein. Une stratégie courante consiste à supprimer le client lorsque le tampon est plein plutôt qu'à bloquer tout le concentrateur.

select {
case c.send <- msg:
default:
    close(c.send)
    delete(h.clients, c)
}

Pourquoi utiliser des canaux plutôt que des verrous

La devise de Go est la suivante : « partager la mémoire en communiquant ». Faire passer toutes les modifications par une seule gouroutine au moyen de canaux évite les conditions de concurrence sur la map des clients sans verrouillage explicite.

Diffuser un message

N'importe quel gestionnaire peut diffuser un message en l'envoyant sur le canal du concentrateur ; le concentrateur le répartit à tous les clients enregistrés.

hub.broadcast <- []byte("server announcement")

Ciblé ou diffusé

Pour les salons ou les messages directs, stockez les clients par salle ou par ID utilisateur et parcourez uniquement le sous-ensemble concerné au lieu de tous les clients. Une conversation comportant de nombreux salons reste ainsi efficace.

Exécutable : répartir avec des canaux

Ce programme autonome représente un concentrateur qui répartit un message vers plusieurs canaux de clients en utilisant uniquement la bibliothèque standard et des gouroutines.

package main

import (
    "fmt"
    "sync"
)

func main() {
    clients := []chan string{make(chan string, 1), make(chan string, 1), make(chan string, 1)}
    msg := "hello all"
    for _, c := range clients {
        c <- msg // fan-out
    }
    var wg sync.WaitGroup
    for i, c := range clients {
        wg.Add(1)
        go func(id int, ch chan string) {
            defer wg.Done()
            fmt.Printf("client %d got: %s\n", id, <-ch)
        }(i, c)
    }
    wg.Wait()
}

Vérification rapide

Vérifiez votre compréhension de la diffusion.

Récapitulatif

Vous avez appris à diffuser des messages à plusieurs clients :

La gouroutine du concentrateur possède l'ensemble des clients et un canal de diffusion
Chaque client possède un canal d'envoi avec tampon, vidé par une gouroutine d'écriture
Cela respecte la règle d'un seul écrivain par connexion
Supprimez les clients lents pour que le concentrateur reste réactif

Questions Fréquemment Posées

La leçon « Diffuser des messages » est-elle gratuite ?

Oui — le texte complet de « Diffuser des messages » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Diffuser des messages » ?

Envoyer des messages à plusieurs clients Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Diffuser des messages » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy