1. ¿Qué es flume y por qué usarla?

La librería flume es una implementación rápida, segura y ergonómica de canales multihilo (channels) para el lenguaje Rust. Proporciona colas asíncronas y síncronas para transferir mensajes entre hilos, inspirada en los canales clásicos de Go y en la librería crossbeam. flume se destaca por su mínimo número de asignaciones de memoria, ausencia de dependencias de la biblioteca estándar (compatible con no_std) y un rendimiento superior, a menudo superando a los canales mpsc estándar de std::sync.

¿Para qué sirve flume? En aplicaciones multihilo en Rust, a menudo necesitas organizar el intercambio de datos entre hilos: un hilo produce datos (productor) y otro los consume (consumidor). Los canales estándar de std::sync::mpsc tienen limitaciones: solo admiten un único consumidor (single-consumer). flume, en cambio, ofrece tanto canales con un solo consumidor (SPSC) como con múltiples consumidores (MPSC), además de soportar programación asíncrona con async/await. Esta librería se usa activamente en sistemas de alta carga, servidores web y motores de videojuegos gracias a su ligereza y velocidad.

Características clave de flume: abstracciones de costo cero (zero-cost abstractions), soporte de contrapresión (backpressure) con límite de tamaño de búfer, posibilidad de clonar tanto emisores como receptores, y compatibilidad total con tokio y async-std. Si necesitas canales rápidos y confiables para Rust, flume es una excelente opción.

2. Instalación

Para instalar flume, agrega la dependencia al archivo Cargo.toml de tu proyecto:

[dependencies]
flume = "0.11"

Luego ejecuta el comando cargo build para descargar y compilar la librería. Si usas las capacidades asíncronas, no necesitas dependencias adicionales: flume soporta async de forma nativa.

3. Inicio rápido — ejemplo mínimo funcional

Vamos a crear un canal simple, enviar un mensaje y recibirlo:

use flume;

fn main() {
    // Creamos un canal sin límite
    let (tx, rx) = flume::unbounded();

    // Enviamos un mensaje
    tx.send("¡Hola desde flume!").unwrap();

    // Recibimos el mensaje
    let msg = rx.recv().unwrap();
    println!("Recibido: {}", msg);
}

Este ejemplo muestra el funcionamiento básico: unbounded() crea un canal sin límite de mensajes, send envía datos y recv bloquea el hilo hasta recibir un mensaje.

4. Métodos y funciones principales

4.1. flume::unbounded()

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

Crea un canal sin límite. Tanto el emisor como el receptor se pueden clonar. Los mensajes se almacenan en un búfer que crece dinámicamente.

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

4.2. flume::bounded(cap: usize)

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

Crea un canal con un búfer limitado de capacidad fija. Cuando el búfer está lleno, send se bloqueará hasta que haya espacio disponible.

let (tx, rx) = flume::bounded(3);
for i in 0..3 {
    tx.send(i).unwrap();
}
// El cuarto envío se bloqueará hasta que se libere espacio
// rx.recv(); // Descomenta para liberar espacio
println!("Capacidad máxima alcanzada");