Canais

A passagem de mensagens permite que threads se comuniquem enviando dados de propriedade através de canais em vez de compartilhar estado mutável. A biblioteca padrão do Rust fornece mpsc; o ecossistema adiciona filas com limite, select e mais.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

use std::sync::mpsc;
use std::thread;
 
fn main() {
    let (tx, rx) = mpsc::channel();
 
    thread::spawn(move || {
        tx.send(42).unwrap();
    });
 
    println!("{}", rx.recv().unwrap());
}

Quando usar isso: Quando trabalhadores produzem resultados, estágios de pipeline passam trabalho, ou você quer evitar locks e mutação compartilhada.

Exemplo de Trabalho

use std::sync::mpsc;
use std::thread;
use std::time::Duration;
 
fn main() {
    let (tx, rx) = mpsc::channel();
    let producer = thread::spawn(move || {
        for i in 0..5 {
            tx.send(i).unwrap();
            thread::sleep(Duration::from_millis(10));
        }
    });
 
    for msg in rx {
        println!("recebido {msg}");
    }
    producer.join().unwrap();
}

O que isso demonstra:

• mpsc::channel cria uma fila ilimitada (a memória pode crescer).
• send move a propriedade; o remetente pode ser clonado para múltiplos produtores.
• Iterar sobre rx bloqueia até que os remetentes sejam descartados e a fila esteja vazia.

Mergulho Profundo

Como Funciona

• Transferência de propriedade: Cada mensagem é movida, não copiada (a menos que Copy). Nenhum lock no corpo da mensagem após o envio.
• Consumidor único: mpsc padrão tem um único receptor. Múltiplos receptores precisam de crossbeam-channel ou padrões de fan-out.
• Backpressure: Canais ilimitados nunca bloqueiam no envio; canais com limite bloqueiam quando cheios.
• Desconexão: recv retorna Err quando todos os remetentes são descartados.

std::sync::mpsc vs crossbeam

Notas de Rust

// Múltiplos produtores: clone o remetente
let (tx, rx) = mpsc::channel();
let tx2 = tx.clone();
thread::spawn(move || { tx.send(1).unwrap(); });
thread::spawn(move || { tx2.send(2).unwrap(); });
drop(tx); // descarta o original para que o iterador rx possa terminar

• Clone Sender antes de mover para cada thread.
• Descarte todos os remetentes quando terminar para que recv possa retornar Disconnected.
• Prefira crossbeam_channel::bounded(n) quando os produtores podem superar os consumidores.

Armadilhas

• Crescimento ilimitado de memória - Produtores rápidos com consumidores lentos enchem a RAM. Correção: Use um canal com limite ou aplique backpressure.
• Esquecer de descartar remetentes - recv bloqueia para sempre se um clone ainda existir. Correção: Rastreie os handles dos remetentes e descarte os extras explicitamente.
• Enviar tipos não Send - Mensagens de canal devem ser Send. Correção: Use Arc ou reestruture; não envie Rc entre threads.
• Mutex dentro de cada mensagem - Anula o propósito da passagem de mensagens. Correção: Envie dados de propriedade ou IDs, não locks compartilhados.
• Panicking no send após desconexão - O receptor foi embora significa que send falha. Correção: Trate Err ou use let _ = tx.send(...) com logging.

Alternativas

FAQs

Relacionados

• Noções Básicas de Concorrência - primeiro exemplo de canal
• Mutex & RwLock - alternativa de estado compartilhado
• Deadlocks & Condições de Corrida - menos corridas com mensagens
• Canais em Tokio - canais assíncronos
• Melhores Práticas de Concorrência - prefira passagem de mensagens

Versões da Stack: Esta página foi escrita para Rust 1.97.0 (edição 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, e Polars 0.46+.