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

Rust में एसिंक्रोनस प्रोग्रामिंग: बुनियादी से उन्नत तकनीकों तक

आधुनिक एप्लिकेशन उच्च प्रदर्शन और I/O संचालन के साथ कुशल कार्य की मांग करते हैं। Rust, अपनी गति और सुरक्षा के लिए जाना जाता है, एसिंक्रोनस प्रोग्रामिंग का एक शक्तिशाली मॉडल प्रदान करता है। इस गाइड में, हम विस्तार से समझेंगे कि तेज़ और विश्वसनीय एसिंक्रोनस प्रोग्राम बनाने के लिए async/await, tokio लाइब्रेरी और अन्य टूल का उपयोग कैसे करें।

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

एसिंक्रोनस प्रोग्रामिंग एक प्रतिमान है जो OS थ्रेड बनाए बिना एक साथ कई कार्यों को निष्पादित करने की अनुमति देता है। I/O (फ़ाइल पढ़ना, HTTP अनुरोध) की प्रतीक्षा करते समय थ्रेड को ब्लॉक करने के बजाय, एक एसिंक्रोनस फ़ंक्शन "रुक जाता है" और नियंत्रण अन्य कार्यों को स्थानांतरित कर देता है। Rust इसे Futures और async/await तंत्र के माध्यम से लागू करता है।

मुख्य अवधारणाएँ:

• Future — एक ट्रेट जो एक एसिंक्रोनस ऑपरेशन का प्रतिनिधित्व करता है जो बाद में पूरा हो सकता है।
• async/await — Futures के साथ काम करने के लिए सिंटैक्टिक शुगर।
• Runtime (निष्पादक) — निष्पादन वातावरण जो Futures को पोल करता है और उन्हें चलाता है। सबसे लोकप्रिय Tokio है।
• Task — कार्य की एक हल्की इकाई, जिसे Runtime द्वारा प्रबंधित किया जाता है।

Rust पर पहला एसिंक्रोनस प्रोग्राम

शुरू करने के लिए, Cargo.toml में निर्भरताएँ जोड़ें:

[dependencies]tokio = { version = "1", features = ["full"] }reqwest = { version = "0.12", features = ["json"] }serde = { version = "1.0", features = ["derive"] }serde_json = "1.0"

अब एक सरल एसिंक्रोनस HTTP क्लाइंट लिखते हैं:

use reqwest;use serde::Deserialize;

#[derive(Deserialize, Debug)]struct Todo {    userId: u32,    id: u32,    title: String,    completed: bool,}

#[tokio::main]async fn main() -> Result<(), Box> {    // एसिंक्रोनस GET अनुरोध    let response = reqwest::get("https://jsonplaceholder.typicode.com/todos/1")        .await?;  // await निष्पादन को रोकता है जब तक प्रतिक्रिया नहीं आती        let todo: Todo = response.json().await?;  // एसिंक्रोनस डिसीरियलाइज़ेशन        println!("प्राप्त कार्य: {:#?}", todo);    Ok(())}

मैक्रो #[tokio::main] पर ध्यान दें — यह सामान्य main फ़ंक्शन को एक एसिंक्रोनस एंट्री पॉइंट में बदल देता है, Tokio Runtime शुरू करता है।

एसिंक्रोनस फ़ंक्शन बनाना और कार्यों के साथ काम करना

आप कीवर्ड async fn का उपयोग करके अपने स्वयं के एसिंक्रोनस फ़ंक्शन बना सकते हैं:

use std::time::Duration;use tokio::time::sleep;

async fn simulate_work(id: u32, duration_secs: u64) -> String {    println!("कार्य {} शुरू हुआ", id);    sleep(Duration::from_secs(duration_secs)).await;  // एसिंक्रोनस विलंब    println!("कार्य {} पूरा हुआ", id);    format!("कार्य {} का परिणाम", id)}

#[tokio::main]async fn main() {    let start = std::time::Instant::now();        // एसिंक्रोनस कार्य (tasks) बनाएँ    let task1 = tokio::spawn(simulate_work(1, 2));    let task2 = tokio::spawn(simulate_work(2, 1));    let task3 = tokio::spawn(simulate_work(3, 3));        // सभी कार्यों के पूरा होने की प्रतीक्षा करें    let results = tokio::join!(task1, task2, task3);        // परिणामों को संसाधित करें    for result in &results {        match result {            Ok(msg) => println!("{}", msg),            Err(e) => eprintln!("त्रुटि: {}", e),        }    }        println!("कुल समय: {:?}", start.elapsed());    // यह ~3 सेकंड में पूरा होगा, 6 में नहीं!}

फ़ंक्शन tokio::spawn एक स्वतंत्र एसिंक्रोनस कार्य बनाता है जो दूसरों के साथ समानांतर में निष्पादित होता है। tokio::join! सभी पास किए गए फ्यूचर्स के पूरा होने की प्रतीक्षा करता है।

उन्नत तकनीक