Rust Task Scheduler: Überblick über Bibliotheken und Codebeispiele

Rust Task Scheduler: Vollständiger Leitfaden für Entwickler

Task-Scheduler sind ein wesentlicher Bestandteil der modernen Entwicklung. Sie ermöglichen die Automatisierung von Routineaufgaben: regelmäßige Cache-Bereinigung, Versenden von Benachrichtigungen, Datensynchronisation und vieles mehr. Im Rust-Ökosystem gibt es mehrere leistungsstarke Bibliotheken zur Implementierung von Schedulern. In diesem Artikel betrachten wir drei Hauptansätze: cron, tokio-cron-scheduler und job_scheduler.

1. Einfacher Scheduler mit der Bibliothek cron

Die Bibliothek cron bietet minimale Funktionalität zum Parsen von Cron-Ausdrücken und zur Berechnung des nächsten Ausführungszeitpunkts. Sie enthält keine integrierte Ausführungsschleife, daher wird sie oft mit tokio oder std::thread kombiniert.

Installation:

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

Beispiel eines einfachen Schedulers:

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

fn main() {    // Jede Minute    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!("[{}] Aufgabe ausgeführt!", Utc::now());        }    }}

Dieser Ansatz bietet volle Kontrolle, erfordert jedoch manuelle Schleifenverwaltung. Geeignet für einfache Szenarien.

2. Asynchroner Scheduler tokio-cron-scheduler

Für moderne asynchrone Anwendungen auf Basis von tokio ist die Bibliothek tokio-cron-scheduler ideal geeignet. Sie bietet einen fertigen Scheduler mit Unterstützung für komplexe Cron-Zeitpläne, Jobs mit IDs und Fehlerbehandlern.

Installation:

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

Beispiel mit zwei Aufgaben:

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?;

    // Aufgabe 1: alle 5 Sekunden    let job1 = Job::new_async("*/5 * * * * *", |_uuid, _lock| {        Box::pin(async move {            println!("[Job1] Ausgeführt um {:?}", std::time::SystemTime::now());        })    })?;

    // Aufgabe 2: jede Minute    let job2 = Job::new_async("0 * * * * *", |_uuid, _lock| {        Box::pin(async move {            println!("[Job2] Minütliche Aufgabe");        })    })?;

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

    // Anwendung am Laufen halten    tokio::signal::ctrl_c().await?;    println!("Scheduler gestoppt");    Ok(())}

Vorteile: automatische Zeitverwaltung, Unterstützung zum Löschen/Pausieren von Aufgaben, blockierungsfreie asynchrone Ausführung.

3. Einfacher Scheduler job_scheduler

Die Bibliothek job_scheduler ist auf maximale Einfachheit ausgelegt. Sie benötigt keine asynchrone Laufzeitumgebung und eignet sich für Konsolen-Dienstprogramme oder die Integration in bestehende synchrone Projekte.

Installation:

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

Beispiel:

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!("Aufgabenausführung alle