1. O que é e para que serve

A biblioteca flume é uma implementação rápida, segura e ergonômica de canais (channels) para multithreading na linguagem Rust. Ela oferece filas assíncronas e síncronas para transferência de mensagens entre threads, inspiradas nos canais clássicos de Go e na biblioteca crossbeam. flume se destaca pelo número mínimo de alocações, ausência de dependências da biblioteca padrão (compatível com no_std) e desempenho superior, muitas vezes superando os canais mpsc padrão de std::sync.

Por que usar flume? Em aplicações multithread em Rust, é comum precisar organizar a troca de dados entre threads: uma thread produz dados (produtor), outra consome (consumidor). Os canais padrão de std::sync::mpsc têm limitações: suportam apenas um consumidor (single-consumer). flume, por sua vez, oferece tanto canais com um consumidor (SPSC) quanto com vários (MPSC), além de suportar programação assíncrona via async/await. A biblioteca é amplamente usada em sistemas de alta carga, servidores web e engines de jogos devido à sua leveza e velocidade.

Principais características do flume: abstrações de custo zero (zero-cost abstractions), suporte a backpressure (limitação do tamanho do buffer), possibilidade de clonar remetentes e destinatários, e compatibilidade total com tokio e async-std. Se você precisa de canais confiáveis e rápidos para Rust, flume é uma excelente escolha.

2. Instalação

Para instalar o flume, adicione a dependência no arquivo Cargo.toml do seu projeto:

[dependencies]
flume = "0.11"

Em seguida, execute o comando cargo build para baixar e compilar a biblioteca. Se você for usar recursos assíncronos, não são necessárias dependências adicionais — o flume suporta async nativamente.

3. Início rápido — exemplo mínimo funcional

Vamos criar um canal simples, enviar uma mensagem e recebê-la:

use flume;

fn main() {
    // Cria um canal ilimitado
    let (tx, rx) = flume::unbounded();

    // Envia uma mensagem
    tx.send("Olá do flume!").unwrap();

    // Recebe a mensagem
    let msg = rx.recv().unwrap();
    println!("Recebido: {}", msg);
}

Este exemplo demonstra o funcionamento básico: unbounded() cria um canal sem limite de mensagens, send envia os dados e recv bloqueia a thread até receber a mensagem.

4. Métodos/funções principais

4.1. flume::unbounded()

Assinatura: pub fn unbounded<T>() -> (Sender<T>, Receiver<T>)

Cria um canal ilimitado. O remetente e o destinatário podem ser clonados. As mensagens são armazenadas em um buffer que cresce dinamicamente.

let (tx, rx) = flume::unbounded::<String>();
tx.send("Olá".to_string()).unwrap();
let msg = rx.recv().unwrap();
println!("{}", msg);

4.2. flume::bounded(cap: usize)

Assinatura: pub fn bounded<T>(cap: usize) -> (Sender<T>, Receiver<T>)

Cria um canal com buffer limitado de capacidade definida. Quando o buffer está cheio, send bloqueia até que haja espaço disponível.

let (tx, rx) = flume::bounded(3);
for i in 0..3 {
    tx.send(i).unwrap();
}
// O quarto envio será bloqueado até que haja espaço
// rx.recv(); // Descomente para liberar espaço
println!("Fim do exemplo");