Filas de tarefas em Rust: criação e gerenciamento de tarefas assíncronas

Trabalhando com filas de tarefas em Rust: do simples ao complexo

Filas de tarefas são um padrão fundamental de programação assíncrona, permitindo distribuir eficientemente recursos computacionais entre múltiplas operações. Em Rust, uma linguagem de programação de sistemas com foco em segurança e desempenho, a implementação de filas de tarefas se destaca especialmente devido ao sistema de ownership, tipos de dados e runtimes assíncronos poderosos como tokio e async-std.

Neste artigo, vamos analisar como criar, gerenciar e otimizar filas de tarefas em Rust. Você aprenderá sobre abordagens síncronas e assíncronas, aprenderá a usar canais para transmissão de mensagens e conhecerá exemplos práticos que podem ser aplicados imediatamente em projetos.

Por que usar filas de tarefas em Rust?

Em aplicações modernas, frequentemente surge a necessidade de executar tarefas assincronamente: processar requisições HTTP, escrever no banco de dados, realizar cálculos em segundo plano. Uma fila de tarefas permite:

• Separar a postagem da tarefa da sua execução — uma thread (ou componente) coloca a tarefa na fila, outra a retira e processa.
• Controlar a carga — limitar o número de tarefas executadas simultaneamente, evitando sobrecarga do sistema.
• Simplificar a escalabilidade — adicionar mais workers (threads processadoras) sem alterar a lógica de postagem de tarefas.
• Aumentar a tolerância a falhas — se um worker falhar, a tarefa permanece na fila e pode ser processada por outro.

Rust, graças ao seu sistema de tipos rigoroso e à ausência de garbage collector, permite criar filas de alto desempenho com sobrecarga mínima.

Fila síncrona com std::sync::mpsc

A biblioteca padrão do Rust fornece o módulo std::sync::mpsc (Multiple Producer, Single Consumer) — um canal multi-thread para transmissão de mensagens. Esta é a maneira mais simples de organizar uma fila de tarefas.

Vamos considerar um exemplo: criaremos uma fila onde a thread principal envia números e a thread trabalhadora os eleva ao quadrado.

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

fn main() {    // Criamos o canal: transmissor e receptor    let (tx, rx) = mpsc::channel::<i32>();

    // Thread worker: processa as tarefas da fila    let worker = thread::spawn(move || {        for received in rx {            println!("Recebido: {}, quadrado: {}", received, received * received);            thread::sleep(Duration::from_millis(100));        }    });

    // Enviamos tarefas para a fila    for i in 1..=10 {        tx.send(i).unwrap();        println!("Enviado: {}", i);    }

    // Fechamos o canal (automaticamente quando tx cai)    drop(tx);

    // Aguardamos a conclusão do worker    worker.join().unwrap();}

Este código demonstra o padrão básico: tx envia dados, rx os recebe em uma thread separada. O canal sincroniza automaticamente o acesso — se o worker estiver ocupado, o transmissor aguardará.

Limitação do mpsc: apenas um consumidor. Para múltiplos workers, seria necessário combinar canais ou usar bibliotecas mais avançadas.

Fila assíncrona com Tokio e tokio::sync::mpsc

Para aplicações assíncronas (servidores web, chats, processamento de eventos), é melhor usar tokio — um runtime assíncrono popular para Rust. Seu canal tokio::sync::mpsc funciona com async/await e suporta múltiplos produtores e consumidores.

Adicione ao Cargo.toml:

[dependencies]tokio = { version = "1", features = ["full"] }

Exemplo de fila assíncrona:

use tokio::sync::mpsc;use tokio::time::{sleep, Duration};

#[tokio