Planificador de tareas Rust: descripción general de bibliotecas y ejemplos de código

Planificador de tareas Rust: guía completa para desarrolladores

Los planificadores de tareas son una parte esencial del desarrollo moderno. Permiten automatizar la ejecución de operaciones rutinarias: limpieza periódica de caché, envío de notificaciones, sincronización de datos y mucho más. En el ecosistema de Rust, existen varias bibliotecas potentes para implementar planificadores. En este artículo, analizaremos tres enfoques principales: cron, tokio-cron-scheduler y job_scheduler.

1. Planificador básico con la biblioteca cron

La biblioteca cron proporciona una funcionalidad minimalista para analizar expresiones cron y calcular la hora de la próxima ejecución. No contiene un bucle de ejecución incorporado, por lo que a menudo se combina con tokio o std::thread.

Instalación:

[dependencies]cron = "0.12"chrono = "0.4"tokio = { version = "1", features = ["full"] }

Ejemplo de un planificador simple:

use cron::Schedule;use chrono::Utc;use std::str::FromStr;use std::thread;use std::time::Duration;

fn main() {    // Cada minuto    let expression = "0 * * * * *";    let schedule = Schedule::from_str(expression).unwrap();

    loop {        let now = Utc::now();        if let Some(next) = schedule.upcoming(Utc).next() {            let duration = next - now;            if duration.num_seconds() > 0 {                thread::sleep(Duration::from_secs(duration.num_seconds() as u64));            }            println!("[{}] ¡Tarea ejecutada!", Utc::now());        }    }}

Este enfoque brinda control total, pero requiere la gestión manual del bucle. Es adecuado para escenarios simples.

2. Planificador asíncrono tokio-cron-scheduler

Para aplicaciones asíncronas modernas basadas en tokio, la biblioteca tokio-cron-scheduler es ideal. Proporciona un planificador listo para usar con soporte para horarios cron complejos, trabajos con identificadores y manejadores de errores.

Instalación:

[dependencies]tokio-cron-scheduler = "0.10"tokio = { version = "1", features = ["full"] }

Ejemplo con dos tareas:

use tokio_cron_scheduler::{Job, JobScheduler};use std::sync::Arc;

#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let sched = JobScheduler::new().await?;

    // Tarea 1: cada 5 segundos    let job1 = Job::new_async("*/5 * * * * *", |_uuid, _lock| {        Box::pin(async move {            println!("[Job1] Ejecutado en {:?}", std::time::SystemTime::now());        })    })?;

    // Tarea 2: cada minuto    let job2 = Job::new_async("0 * * * * *", |_uuid, _lock| {        Box::pin(async move {            println!("[Job2] Tarea de cada minuto");        })    })?;

    sched.add(job1).await?;    sched.add(job2).await?;    sched.start().await?;

    // Mantenemos la aplicación en ejecución    tokio::signal::ctrl_c().await?;    println!("Planificador detenido");    Ok(())}

Ventajas: gestión automática del tiempo, soporte para eliminar/pausar tareas, ejecución asíncrona sin bloqueos.

3. Planificador simple job_scheduler

La biblioteca job_scheduler está orientada a la máxima simplicidad. No requiere un runtime asíncrono y es adecuada para utilidades de consola o para integrarse en proyectos síncronos existentes.

Instalación:

[dependencies]job_scheduler = "1.2"chrono = "0.4"

Ejemplo:

use job_scheduler::{Job, JobScheduler};use std::time::Duration;

fn main() {    let mut sched = JobScheduler::new();

    sched.add(Job::new("1/10 * * * * *".parse().unwrap(), || {        println!("Ejecutando tarea cada