Lição 42: Channels (Comunicação por Mensagens)

1. Narrativa

Quando os braços do mecha precisam se coordenar em combate, eles usam canais de comunicação — rádios seguros que permitem trocar mensagens sem interferência. Channels em Rust são como esses rádios: permitem que threads se comuniquem enviando mensagens, sem precisar de memória compartilhada ou locks complexos. "Não se comunique compartilhando memória; compartilhe memória comunicando-se."

2. Conceito

Channels (canais) são a principal forma de comunicação entre threads em Rust:

• mpsc: Multiple Producer, Single Consumer — múltiplos remetentes, um destinatário
• tx.send(valor): Envia um valor pelo canal (move ownership)
• rx.recv(): Bloqueia até receber uma mensagem
• rx.try_recv(): Tenta receber sem bloquear ( retorna Err se vazio)
• rx.iter(): Iterator que recebe mensagens até o canal fechar
• Drop do transmissor: Quando todos os tx são dropados, rx.iter() termina

3. Requisitos

• Criar canais com mpsc::channel()
• Enviar dados pelo transmissor (tx.send)
• Receber dados pelo receptor (rx.recv, rx.iter)
• Usar múltiplos transmissores (clone de tx)
• Demonstrar o padrão de drop do transmissor para finalizar recepção

4. Design de Dados

graph LR
    A[Thread 1: tx1] --> D[Canal mpsc]
    B[Thread 2: tx2] --> D
    C[Thread 3: tx3] --> D
    D --> E[Thread Principal: rx]

5. Diagrama de Fluxo

flowchart TD
    A[Criar canal] --> B[tx.send dados]
    B --> C{Mais dados?}
    C -->|Sim| B
    C -->|Não| D[Drop tx]
    D --> E[rx.recv / rx.iter]
    E --> F{tx dropado?}
    F -->|Não| G[Processar mensagem]
    G --> E
    F -->|Sim| H[Finalizar]

6. Funções

Função	Descrição
enviar_e_receber	Envia valores por canal e coleta no receptor
transformar_via_canal	Envia string e retorna maiúscula
multiplos_transmissores	Múltiplos tx enviam dados em paralelo
filtrar_logs_canal	Filtra mensagens de log por nível via canal
contar_mensagens	Conta mensagens recebidas pelo canal
testar_canal	Testa ciclo completo send/recv
pipeline_dobrar	Pipeline: envia → dobra → coleta
enviar_e_finalizar	Envia dados e drop tx para finalizar rx.iter()

7. Exemplo

use std::sync::mpsc;
use std::thread;

let (tx, rx) = mpsc::channel();
thread::spawn(move || {
    tx.send(42).unwrap();
});
let valor = rx.recv().unwrap();
assert_eq!(valor, 42);

8. Missão

1. Implementar enviar_e_receber com canal básico send/recv
2. Implementar transformar_via_canal enviando string e recebendo transformada
3. Implementar multiplos_transmissores clonando tx para múltiplos produtores
4. Implementar filtrar_logs_canal enviando structs e filtrando no receptor
5. Implementar contar_mensagens enviando N mensagens e contando
6. Implementar testar_canal com ciclo simples send/recv
7. Implementar pipeline_dobrar transformando dados via canal
8. Implementar enviar_e_finalizar usando drop(tx) para terminar rx.iter()

9. Como Executar

cargo build
cargo test
cargo clippy -- -D warnings
cargo fmt --check

10. Dicas

• send() move ownership do valor — dados não são copiados
• Clone tx para ter múltiplos produtores (cada clone é um remetente)
• rx.iter() termina automaticamente quando todos os tx são dropados
• recv() retorna Result<T, RecvError> — Err quando todos tx foram dropados
• Channels são seguros — o tipo system garante que só o receptor consome