Планировщик задач Rust: библиотеки и примеры

Планировщик задач на Rust: полное руководство по библиотекам и реализации

В современной разработке серверных приложений и систем автоматизации планировщик задач (task scheduler) является одним из ключевых компонентов. Rust, благодаря своей производительности и безопасности памяти, предлагает несколько мощных решений для создания гибких и эффективных планировщиков. В этой статье мы подробно рассмотрим основные библиотеки для планирования задач на Rust, их возможности, примеры использования и сравнение с аналогами на Python.

Основные библиотеки для планирования задач в Rust

Экосистема Rust предлагает несколько зрелых решений для работы с планировщиками задач. Рассмотрим три наиболее популярные библиотеки:

tokio-schedule — асинхронный планировщик на основе tokio, поддерживающий cron-выражения и интервальные задачи
cron — легковесная библиотека для работы с cron-выражениями, часто используется вместе с tokio
async-task-scheduler — высокоуровневый планировщик с поддержкой приоритетов, повторов и сложных правил запуска

Установка и настройка tokio-schedule

Для начала работы добавьте зависимости в ваш Cargo.toml:

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

Пример 1: Простой планировщик с интервалом

Создадим базовый планировщик, который выполняет задачу каждые 5 секунд:

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

#[tokio::main]
async fn main() {
    // Создаем задачу, которая выполняется каждые 5 секунд
    let job = Job::new()
        .every(Duration::from_secs(5))
        .run(|| async {
            println!("Задача выполнена в: {}", chrono::Local::now());
        });

    println!("Планировщик запущен. Нажмите Ctrl+C для остановки.");
    job.start().await;
    
    // Бесконечное ожидание
    loop {
        sleep(Duration::from_secs(1)).await;
    }
}

Пример 2: Планировщик с cron-выражением

Более сложный пример с использованием cron-синтаксиса для точного контроля времени выполнения:

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();

    // Запуск каждую минуту в 30 секунд
    let job = Job::new()
        .cron("30 * * * * *") // секунда, минута, час, день, месяц, день_недели
        .run(move || {
            let cnt = counter_clone.fetch_add(1, Ordering::SeqCst);
            async move {
                println!("[{}] Выполнение задачи в: {}", cnt, chrono::Local::now());
                // Здесь может быть ваша бизнес-логика
                simulate_work().await;
            }
        });

    println!("Планировщик с cron запущен.");
    job.start().await;

    // Демонстрация работы в течение 2 минут
    tokio::time::sleep(Duration::from_secs(120)).await;
}

async fn simulate_work() {
    // Имитация работы
    tokio::time::sleep(Duration::from_millis(500)).await;
}

Пример 3: Планировщик с несколькими задачами и приоритетами

Использование библиотеки async-task-scheduler для управления несколькими задачами:

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

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

    // Высокоприоритетная задача — выполняется каждые 2 секунды
    scheduler.add_task(
        Task::new("high_priority_task", || async {
            println!("[HIGH] Срочная задача выполнена");
        })
        .interval(Duration::from_secs(2))
        .priority(Priority::High)
    );

    // Низкоприоритетная задача — выполняется каждые 10 секунд
    scheduler.add_task(
        Task::new("low_priority_task", || async {
            println!("[LOW] Фоновая задача выполнена");
        })
        .interval(Duration::from_secs(10))
        .priority(Priority::Low)
    );

    // Задача с отложенным стартом
    scheduler.add_task(
        Task::new("delayed_task", || async {
            println!("[DELAYED] Запуск после задержки");
        })
        .delay(Duration::from_secs(30))
        .run_once()
    );

    // Запуск планировщика
    scheduler.start().await;
}