Rust में एसिंक्रोनस प्रोग्रामिंग: उदाहरणों के साथ पूर्ण गाइड

Rust में एसिंक्रोनस प्रोग्रामिंग का परिचय

एसिंक्रोनस प्रोग्रामिंग एक प्रतिमान है जो इनपुट-आउटपुट संचालन (नेटवर्क अनुरोध, फ़ाइल पढ़ना, डेटाबेस के साथ काम करना) को मुख्य निष्पादन थ्रेड को ब्लॉक किए बिना निष्पादित करने की अनुमति देता है। Rust में, एसिंक्रोनसी Future सिस्टम और async/await कीवर्ड के माध्यम से कार्यान्वित की जाती है। मल्टीथ्रेडिंग के विपरीत, एसिंक्रोनस कोड एक ही थ्रेड में काम करता है, प्रतीक्षा के दौरान कार्यों के बीच स्विच करता है।

इस गाइड में, हम निम्नलिखित को समझेंगे:

• Rust में async/await की मूल बातें
• क्रेट tokio के साथ काम करना — सबसे लोकप्रिय एसिंक्रोनस रनटाइम
• Future बनाना और संयोजित करना
• व्यावहारिक उदाहरण: एसिंक्रोनस HTTP क्लाइंट और टाइमर

यह लेख उन डेवलपर्स के लिए है जो Rust के बुनियादी सिंटैक्स से परिचित हैं। यदि आप अभी शुरुआत कर रहे हैं — तो पहले PythonLib पर भाषा की मूल बातें सीखने की सलाह दी जाती है।

Rust में async/await और Future की मूल बातें

Future क्या है?

Future एक ट्रेट है जो एक एसिंक्रोनस ऑपरेशन का प्रतिनिधित्व करता है जो भविष्य में पूरा हो सकता है। Rust में, Future आलसी है: यह तब तक कुछ नहीं करता जब तक इसकी जांच (poll) न की जाए। जांच के लिए एसिंक्रोनस रनटाइम (जैसे, Tokio) जिम्मेदार है।

एक सरल एसिंक्रोनस फ़ंक्शन का उदाहरण:

use std::time::Duration;

async fn say_hello() {    println!("एसिंक्रोनस दुनिया में आपका स्वागत है!");    tokio::time::sleep(Duration::from_secs(1)).await;    println!("1 सेकंड बीत गया");}

#[tokio::main]async fn main() {    say_hello().await;}

कीवर्ड async फ़ंक्शन को Future में बदल देता है। .await को कॉल करना थ्रेड को ब्लॉक किए बिना, Future के पूरा होने तक वर्तमान कार्य के निष्पादन को रोक देता है।

एसिंक्रोनस कार्य का जीवनचक्र

जब आप .await कॉल करते हैं, तो निम्नलिखित होता है:

1. रनटाइम Future की जांच करता है (विधि poll() को कॉल करता है)
2. यदि Future तैयार है — परिणाम लौटाया जाता है
3. यदि Future प्रतीक्षा कर रहा है (उदाहरण के लिए, नेटवर्क ऑपरेशन) — रनटाइम दूसरे कार्य पर स्विच करता है
4. जब संसाधन उपलब्ध हो जाता है, रनटाइम कार्य को फिर से शुरू करता है

Rust की एक महत्वपूर्ण विशेषता: .await को केवल एसिंक्रोनस फ़ंक्शन या async {} ब्लॉक के अंदर ही कॉल किया जा सकता है। इसे सिंक्रोनस संदर्भ में उपयोग करने का प्रयास करने पर कंपाइलेशन त्रुटि होगी।

Tokio के साथ व्यावहारिक कार्य

स्थापना और कॉन्फ़िगरेशन

Tokio Rust के लिए एक एसिंक्रोनस रनटाइम है जो टास्क शेड्यूलर, टाइमर, नेटवर्क सॉकेट और बहुत कुछ प्रदान करता है। आरंभ करने के लिए, Cargo.toml में जोड़ें:

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

फ़्लैग features = ["full"] Tokio की सभी क्षमताओं को शामिल करता है। प्रोडक्शन के लिए केवल आवश्यक सुविधाओं का चयन करना बेहतर है।

एकाधिक एसिंक्रोनस कार्य चलाना

एसिंक्रोनसिटी का एक मुख्य लाभ कई कार्यों का समानांतर निष्पादन है। पृष्ठभूमि में कार्य शुरू करने के लिए tokio::spawn का उपयोग करें:

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

async fn task(name: &str, seconds: u64) {    println!("कार्य {} शुरू हुआ", name);    sleep(Duration::from_secs(seconds)).await;    println!("कार्य {} {} सेकंड में पूरा हुआ", name, seconds);}

#[tokio::main]async fn main() {    let handle1 = tokio::spawn(task("A", 2));    let handle2 = tokio::spawn(task("B", 1));

    // दोनों कार्यों के पूरा होने की प्रतीक्षा करें    let _ = tokio::join!(handle1, handle2);    println!("सभी कार्य पूरे हो गए");}

मैक्रो tokio::join! सभी पास किए गए Future के पूरा होने की प्रतीक्षा करता है। यदि एक कार्य पहले पूरा हो जाता है, तो निष्पादन बाधित नहीं होगा — हम बाकी की प्रतीक्षा करेंगे।

एसिंक्रोनस कोड में त्रुटि प्रबंधन