Rust में अतुल्यकालिक प्रोग्रामिंग: पूर्ण व्यावहारिक मार्गदर्शिका

Rust में अतुल्यकालिक प्रोग्रामिंग का परिचय

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

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

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

Future क्या है?

Future एक ट्रेट है जो एक अतुल्यकालिक ऑपरेशन का प्रतिनिधित्व करता है जो भविष्य में पूरा हो सकता है। Rust में, Future एक आलसी इकाई है: यह तब तक कुछ नहीं करता जब तक इसकी जाँच (poll) न की जाए। मूल विचार: थ्रेड को ब्लॉक करने के बजाय, हम एक कार्य पंजीकृत करते हैं और जब परिणाम तैयार होता है तो उसे प्राप्त करते हैं।

use std::future::Future;\nuse std::pin::Pin;\nuse std::task::{Context, Poll};\n\nstruct MyFuture {\n    ready: bool,\n}\n\nimpl Future for MyFuture {\n    type Output = u32;\n\n    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<u32> {\n        if self.ready {\n            Poll::Ready(42)\n        } else {\n            // पुनः जाँच के लिए waker पंजीकृत करें\n            cx.waker().wake_by_ref();\n            Poll::Pending\n        }\n    }\n}

async/await — सिंटैक्टिक शुगर

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

use tokio::time::{sleep, Duration};\n\nasync fn fetch_data() -> String {\n    // नेटवर्क अनुरोध का अनुकरण\n    sleep(Duration::from_secs(2)).await;\n    String::from("डेटा प्राप्त हुआ")\n}\n\n#[tokio::main]\nasync fn main() {\n    let result = fetch_data().await;\n    println!("{}", result);\n}

जीवनचक्र और borrow checker

Rust की एक विशेषता उधार का सख्त नियंत्रण है। अतुल्यकालिक कोड में यह विशेष रूप से महत्वपूर्ण है, क्योंकि Future उधार लिए गए डेटा से अधिक समय तक जीवित रह सकता है। स्वामित्व लेने के लिए async move का उपयोग करें:

async fn process_data(data: Vec<u32>) -> u32 {\n    data.iter().sum()\n}\n\n#[tokio::main]\nasync fn main() {\n    let numbers = vec![1, 2, 3, 4, 5];\n    let sum = process_data(numbers).await;\n    println!("योग: {}", sum);\n}

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

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

Tokio Rust के लिए सबसे लोकप्रिय अतुल्यकालिक रनटाइम है। Cargo.toml में जोड़ें:

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

अतुल्यकालिक TCP सर्वर बनाना

एक सरल इको सर्वर पर विचार करें जो कनेक्शन स्वीकार करता है और प्राप्त डेटा वापस भेजता है:

use tokio::net::TcpListener;\nuse tokio::io::{AsyncReadExt, AsyncWriteExt};\n\n#[tokio::main]\nasync fn main() -> Result<(), Box<dyn std::error::Error>> {\n    let listener = TcpListener::bind("127.0.0.1:8080").await?;\n    println!("सर्वर पोर्ट 8080 पर शुरू हुआ");\n\n    loop {\n        let (mut socket, addr) = listener.accept().await?;\n        println!("से नया कनेक्शन: {}", addr);\n\n        tokio::spawn(async move {\n            let mut buf = [0; 1024];\n            loop {\n                let n = socket.read(&mut buf).await.unwrap();\n                if n == 0 { break; } // कनेक्शन बंद\n                socket.write_all(&buf[..n]).await.unwra