Channels em Rust: Comunicação entre Threads com mpsc na Prática Já leu

Entendendo Channels e o Padrão MPSC

Channels (canais) em Rust são primitivas de sincronização que implementam o padrão MPSC (Multiple Producer, Single Consumer). Isso significa que múltiplas threads podem enviar mensagens através de um canal, mas apenas uma thread pode receber. Esse padrão evita condições de corrida e garante segurança de memória — características fundamentais do Rust.

O channel em Rust é composto por dois extremos: um sender (transmissor) e um receiver (receptor). Quando você cria um channel, ambos são retornados juntos. O sender pode ser clonado para múltiplas threads produzirem dados, enquanto o receiver permanece singular. Essa restrição não é uma limitação, mas sim um design que força você a pensar corretamente sobre concorrência.

Por que não usar mutex?

Um mutex protege dados compartilhados, mas não coordena a comunicação entre threads. Channels, por outro lado, são ideais quando você precisa que uma thread notifique outra sobre novos dados. Mutex = compartilhamento de estado; Channel = passagem de mensagens.

Criando e Usando Channels Básicos

A criação de um channel é simples através da função mpsc::channel(). Vejamos um exemplo prático:

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

fn main() {
    // Cria um novo channel MPSC
    let (tx, rx) = mpsc::channel();

    // Thread produtora
    thread::spawn(move || {
        let mensagem = String::from("Olá da thread!");
        tx.send(mensagem).unwrap();
    });

    // Thread principal recebe
    let valor_recebido = rx.recv().unwrap();
    println!("Recebi: {}", valor_recebido);
}

No código acima, tx é o transmissor (sender) e rx é o receptor. O move garante que o ownership de tx seja transferido para a closure. O método send() envia um valor e retorna um Result, que deve ser tratado. Se o receptor foi droppado, send() retorna erro.

Enviando Múltiplas Mensagens

Frequentemente você precisa enviar vários dados sequenciais. Use um loop no produtor:

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let dados = vec!["Mensagem 1", "Mensagem 2", "Mensagem 3"];
        for msg in dados {
            tx.send(msg).unwrap();
            thread::sleep(Duration::from_millis(500));
        }
    });

    // Itera sobre todas as mensagens até o canal fechar
    for valor in rx {
        println!("Recebido: {}", valor);
    }
}

Aqui, o receptor implementa IntoIterator, permitindo iteração direta. Quando o sender é droppado, a iteração termina automaticamente.

Canais com Múltiplos Produtores

O verdadeiro poder do MPSC emerge quando múltiplas threads produzem simultaneamente. Clone o sender para cada produtor:

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

fn main() {
    let (tx, rx) = mpsc::channel();

    // Produtor 1
    let tx1 = tx.clone();
    thread::spawn(move || {
        tx1.send("Dados da thread 1").unwrap();
    });

    // Produtor 2
    let tx2 = tx.clone();
    thread::spawn(move || {
        tx2.send("Dados da thread 2").unwrap();
    });

    // Não esqueça de dropar o transmissor original
    drop(tx);

    // Receptor consome ambas as mensagens
    for valor in rx {
        println!("Recebido: {}", valor);
    }
}

Detalhe crítico: Você deve dropar o sender original após clonar. Se deixar tx vivo, o receptor nunca saberá quando parar de esperar, pois ainda há um produtor ativo.

Canais Bounded vs Unbounded

Por padrão, mpsc::channel() cria um unbounded (ilimitado) — a fila interna cresce indefinidamente. Para controlar memória, use mpsc::sync_channel(n) que limita o buffer a n mensagens:

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

fn main() {
    let (tx, rx) = mpsc::sync_channel(2); // Buffer de 2 mensagens

    thread::spawn(move || {
        tx.send(1).unwrap(); // Ok
        tx.send(2).unwrap(); // Ok
        tx.send(3).unwrap(); // Bloqueia até algo ser recebido!
    });

    thread::sleep(std::time::Duration::from_secs(1));
    println!("Recebido: {}", rx.recv().unwrap());
}

Com sync_channel(2), o terceiro send() bloqueia porque o buffer está cheio. Isso oferece backpressure automática — produtores rápidos são freados se o receptor não acompanhar.

Tratamento de Erros com Channels

Cometa um erro comum: ignorar Result. Aqui está o tratamento correto:

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

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        match tx.send("Olá") {
            Ok(_) => println!("Mensagem enviada com sucesso"),
            Err(_) => println!("Receptor foi droppado!"),
        }
    });

    // Se o receptor é droppado antes de receber
    drop(rx);
    thread::sleep(std::time::Duration::from_millis(100));
}

send() retorna Err apenas se o receptor foi droppado. Para o lado receptor, recv() retorna Err se todos os senders foram droppados. Use try_recv() para não-blocking:

match rx.try_recv() {
    Ok(msg) => println!("Mensagem: {}", msg),
    Err(mpsc::TryRecvError::Empty) => println!("Nada aguardando"),
    Err(mpsc::TryRecvError::Disconnected) => println!("Canal fechado"),
}

Conclusão

MPSC channels em Rust são a ferramenta ideal para comunicação entre threads porque combinam segurança, performance e clareza de intenção. Três aprendizados principais:

1. Channels garantem segurança sem deadlocks — o padrão MPSC força uma arquitetura saudável onde produtores e consumidores têm papéis bem definidos.

2. Clone o sender, nunca o receiver — essa assimetria é proposital e evita condições de corrida na sincronização.

3. Sempre trate erros e gerencie lifetimes — dropar senders explicitamente e usar sync_channel para backpressure são detalhes que separam código robusto de código frágil.

Para sistemas concorrentes em Rust, channels são superiores a mutex compartilhado. Use-os como primeira opção em comunicação inter-thread.

Referências

• Rust Official Documentation - std::sync::mpsc
• The Rust Book - Fearless Concurrency
• Rust by Example - Channels
• Tokio - Async Channels Guide