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

    // निम्न प्राथमिकता वाला कार्य — नि