Planejador de Tarefas em Rust: Visão Geral das Bibliotecas e Implementação

Planejador de Tarefas em Rust: Guia Completo de Bibliotecas e Implementação

No desenvolvimento moderno de aplicações servidoras e sistemas de automação, o planejador de tarefas (task scheduler) é um dos componentes-chave. Rust, graças ao seu desempenho e segurança de memória, oferece várias soluções poderosas para criar planejadores flexíveis e eficientes. Neste artigo, abordaremos em detalhes as principais bibliotecas para planejamento de tarefas em Rust, suas funcionalidades, exemplos de uso e comparação com equivalentes em Python.

Principais Bibliotecas para Planejamento de Tarefas em Rust

O ecossistema Rust oferece várias soluções maduras para trabalhar com planejadores de tarefas. Vamos considerar as três bibliotecas mais populares:

• tokio-schedule — planejador assíncrono baseado em tokio, suportando expressões cron e tarefas intervaladas
• cron — biblioteca leve para trabalhar com expressões cron, frequentemente usada junto com tokio
• async-task-scheduler — planejador de alto nível com suporte a prioridades, repetições e regras complexas de execução

Instalação e Configuração do tokio-schedule

Para começar, adicione as dependências ao seu Cargo.toml:

[dependencies]tokio = { version = "1.0", features = ["full"] }tokio-schedule = "0.4"chrono = "0.4"

Exemplo 1: Planejador Simples com Intervalo

Vamos criar um planejador básico que executa uma tarefa a cada 5 segundos:

use tokio::time::{sleep, Duration};use tokio_schedule::Job;

#[tokio::main]async fn main() {    // Criando uma tarefa que executa a cada 5 segundos    let job = Job::new()        .every(Duration::from_secs(5))        .run(|| async {            println!("Tarefa executada em: {}", chrono::Local::now());        });

    println!("Planejador iniciado. Pressione Ctrl+C para parar.");    job.start().await;        // Espera infinita    loop {        sleep(Duration::from_secs(1)).await;    }}

Exemplo 2: Planejador com Expressão Cron

Um exemplo mais complexo usando sintaxe cron para controle preciso do tempo de execução:

use tokio_schedule::Job;use std::sync::Arc;use std::sync::atomic::{AtomicU64, Ordering};

#[tokio::main]async fn main() {    let counter = Arc::new(AtomicU64::new(0));    let counter_clone = counter.clone();

    // Execução a cada minuto aos 30 segundos    let job = Job::new()        .cron("30 * * * * *") // segundo, minuto, hora, dia, mês, dia_da_semana        .run(move || {            let cnt = counter_clone.fetch_add(1, Ordering::SeqCst);            async move {                println!("[{}] Execução da tarefa em: {}", cnt, chrono::Local::now());                // Sua lógica de negócio pode estar aqui                simulate_work().await;            }        });

    println!("Planejador com cron iniciado.");    job.start().await;

    // Demonstração de funcionamento por 2 minutos    tokio::time::sleep(Duration::from_secs(120)).await;}

async fn simulate_work() {    // Simulação de trabalho    tokio::time::sleep(Duration::from_millis(500)).await;}

Exemplo 3: Planejador com Múltiplas Tarefas e Prioridades

Usando a biblioteca async-task-scheduler para gerenciar múltiplas tarefas:

use async_task_scheduler::{Scheduler, Task, Priority};use std::time::Duration;

#[tokio::main]async fn main() {    let mut scheduler = Scheduler::new();

    // Tarefa de alta prioridade — executa a cada 2 segundos    scheduler.add_task(        Task::new("high_priority_task", || async {            println!("[HIGH] Tarefa urgente executada");        })        .interval(Duration::from_secs(2))        .priority(Priority::High)    );

    // Tarefa de baixa prioridade — ex