Go Academy · Aula

Transmissão de mensagens

Envie mensagens para vários clientes

Transmissão de mensagens é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Enviando para vários clientes

Salas de conversa e fluxos em tempo real precisam enviar uma única mensagem para todos os clientes conectados. Como cada WebSocket permite apenas um escritor, você precisa de um padrão de coordenação: o hub.

O padrão Hub

Um hub é uma gorrotina central que mantém o conjunto de clientes e um canal de transmissão. Os clientes se registram e cancelam o registro, e o hub distribui as mensagens. Nenhum mapa compartilhado é acessado diretamente por várias gorrotinas.

Estruturas de dados do Hub

O hub mantém:

Um conjunto de clientes (map[*Client]bool)
Um canal broadcast de mensagens
Canais register e unregister

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

O loop de execução do Hub

Uma única gorrotina Run seleciona entre os canais. Como somente essa gorrotina modifica o mapa, nenhum mutex é necessário.

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 de envio por cliente

Cada cliente tem um send chan []byte com buffer. O hub escreve nele; uma gorrotina de escrita dedicada o esvazia e envia os dados ao socket. Isso respeita a regra de um único escritor.

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

A gorrotina de escrita

Cada cliente executa uma writePump que percorre send e escreve no socket. Se o canal for fechado, ela envia um quadro de fechamento.

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

Evitando clientes lentos

Se um cliente estiver lento, seu send com buffer ficará cheio. Uma política comum é: se o buffer estiver cheio, remover o cliente em vez de bloquear todo o hub.

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

Por que canais em vez de mutexes

O lema do Go é: "compartilhe memória comunicando-se". Direcionar todas as modificações por meio de uma única gorrotina usando canais evita condições de corrida no mapa de clientes sem bloqueios explícitos.

Transmitindo uma mensagem

Qualquer manipulador pode transmitir enviando uma mensagem pelo canal do hub; o hub distribui a mensagem a todos os clientes registrados.

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

Direcionada versus transmissão

Para salas ou mensagens diretas, armazene os clientes indexados pela sala ou pelo ID do usuário e percorra apenas o subconjunto relevante, em vez de todos os clientes. Isso mantém eficiente uma conversa com muitas salas.

Executável: distribuição com canais

Este programa autocontido modela um hub distribuindo uma mensagem por vários canais de clientes usando apenas a biblioteca padrão e gorrotinas.

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

Verificação rápida

Teste sua compreensão da transmissão.

Recapitulação

Você aprendeu a transmitir para vários clientes:

A gorrotina do hub mantém o conjunto de clientes e um canal de transmissão
Cada cliente tem um canal de envio com buffer, esvaziado por uma gorrotina de escrita
Isso respeita a regra de um escritor por conexão
Remova clientes lentos para manter o hub responsivo

Perguntas Frequentes

A aula “Transmissão de mensagens” é grátis?

Sim — o texto completo de “Transmissão de mensagens” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Transmissão de mensagens”?

Envie mensagens para vários clientes Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Transmissão de mensagens”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy