Rust में कार्य कतारें: एसिंक्रोनस कार्यों का निर्माण और प्रबंधन

Rust में कार्य कतारों के साथ काम करना: सरल से जटिल तक

कार्य कतारें एसिंक्रोनस प्रोग्रामिंग का एक मूलभूत पैटर्न हैं, जो कई संचालनों के बीच कंप्यूटिंग संसाधनों को कुशलतापूर्वक वितरित करने की अनुमति देता है। Rust में, सुरक्षा और प्रदर्शन पर ध्यान केंद्रित करने वाली सिस्टम प्रोग्रामिंग भाषा, कार्य कतारों का कार्यान्वयन स्वामित्व प्रणाली, डेटा प्रकारों और tokio और async-std जैसे शक्तिशाली एसिंक्रोनस रनटाइम के कारण विशेष रूप से उजागर होता है।

इस लेख में, हम चर्चा करेंगे कि Rust में कार्य कतारों को कैसे बनाया, प्रबंधित और अनुकूलित किया जाए। आप सिंक्रोनस और एसिंक्रोनस दृष्टिकोणों के बारे में जानेंगे, संदेशों को स्थानांतरित करने के लिए चैनलों का उपयोग करना सीखेंगे, और व्यावहारिक उदाहरणों से परिचित होंगे जिन्हें आप तुरंत अपनी परियोजनाओं में लागू कर सकते हैं।

Rust में कार्य कतारों की आवश्यकता क्यों है?

आधुनिक अनुप्रयोगों में, अक्सर कार्यों को एसिंक्रोनस रूप से निष्पादित करने की आवश्यकता होती है: HTTP अनुरोधों को संसाधित करना, डेटाबेस में लिखना, बैकग्राउंड गणना करना। कार्य कतार अनुमति देती है:

• कार्य सेट करने और उसके निष्पादन को अलग करना — एक थ्रेड (या घटक) कार्य को कतार में रखता है, दूसरा उसे लेता है और संसाधित करता है।
• लोड को नियंत्रित करना — एक साथ निष्पादित कार्यों की संख्या को सीमित करना, सिस्टम ओवरलोड से बचना।
• स्केलिंग को सरल बनाना — कार्य सेट करने के तर्क को बदले बिना अधिक वर्कर (प्रोसेसिंग थ्रेड) जोड़ना।
• फॉल्ट टॉलरेंस बढ़ाना — एक वर्कर के विफल होने पर, कार्य कतार में रहता है और दूसरे वर्कर द्वारा संसाधित किया जा सकता है।

Rust, अपनी सख्त प्रकार प्रणाली और गार्बेज कलेक्टर की अनुपस्थिति के कारण, न्यूनतम ओवरहेड के साथ उच्च-प्रदर्शन कतारें बनाने की अनुमति देता है।

std::sync::mpsc के माध्यम से सिंक्रोनस कतार

Rust की मानक लाइब्रेरी मॉड्यूल std::sync::mpsc (Multiple Producer, Single Consumer) प्रदान करती है — संदेशों को स्थानांतरित करने के लिए एक मल्टीथ्रेडेड चैनल। यह कार्य कतार को व्यवस्थित करने का सबसे सरल तरीका है।

एक उदाहरण पर विचार करें: हम एक कतार बनाएंगे जिसमें मुख्य थ्रेड संख्याएँ भेजता है, और वर्कर थ्रेड उनका वर्ग निकालता है।

use std::sync::mpsc;use std::thread;use std::time::Duration;

fn main() {    // चैनल बनाएँ: प्रेषक और प्राप्तकर्ता    let (tx, rx) = mpsc::channel::<i32>();

    // वर्कर थ्रेड: कतार से कार्यों को संसाधित करता है    let worker = thread::spawn(move || {        for received in rx {            println!("प्राप्त: {}, वर्ग: {}", received, received * received);            thread::sleep(Duration::from_millis(100));        }    });

    // कतार में कार्य भेजें    for i in 1..=10 {        tx.send(i).unwrap();        println!("भेजा: {}", i);    }

    // चैनल बंद करें (tx के गिरने पर स्वचालित रूप से)    drop(tx);

    // वर्कर के पूरा होने की प्रतीक्षा करें    worker.join().unwrap();}

यह कोड एक बुनियादी पैटर्न प्रदर्शित करता है: tx डेटा भेजता है, rx इसे एक अलग थ्रेड में प्राप्त करता है। चैनल स्वचालित रूप से एक्सेस को सिंक्रोनाइज़ करता है — यदि वर्कर व्यस्त है, तो प्रेषक प्रतीक्षा करेगा।

mpsc की सीमा: केवल एक उपभोक्ता। कई वर्कर के लिए, या तो चैनलों को संयोजित करना होगा या अधिक उन्नत लाइब्रेरी का उपयोग करना होगा।

Tokio और tokio::sync::mpsc के साथ एसिंक्रोनस कतार

एसिंक्रोनस अनुप्रयोगों (वेब सर्वर, चैट, इवेंट प्रोसेसिंग) के लिए tokio का उपयोग करना बेहतर है — Rust के लिए एक लोकप्रिय एसिंक्रोनस रनटाइम। इसका चैनल tokio::sync::mpsc async/await के साथ काम करता है और कई प्रोड्यूसर और कंज्यूमर का समर्थन करता है।

Cargo.toml में जोड़ें:

[dependencies]tokio = { version = "1", features = ["full"] }

एसिंक्रोनस कतार का उदाहरण:

use tokio::sync::mpsc;use tokio::time::{sleep, Duration};

#[tokio: