Tokio Rust: मेथड्स, उदाहरण, इंस्टॉलेशन

Tokio क्या है और इसकी ज़रूरत क्यों है?

Tokio, Rust प्रोग्रामिंग भाषा के लिए एक asynchronous रनटाइम है। यह तेज़, विश्वसनीय और स्केलेबल नेटवर्क एप्लिकेशन लिखने के लिए इन्फ्रास्ट्रक्चर प्रदान करता है। अगर आप Rust में कुछ ऐसा लिख रहे हैं जो नेटवर्क, फ़ाइलों या थ्रेड्स को ब्लॉक किए बिना समानांतर प्रोसेसिंग से जुड़ा है — तो आपको Tokio चाहिए।

पारंपरिक मल्टीथ्रेडेड दृष्टिकोण के विपरीत, जहां हर अनुरोध OS के एक अलग थ्रेड में प्रोसेस होता है (जो महंगा और सीमित है), Tokio इवेंट-बेस्ड asynchronous I/O मॉडल का उपयोग करता है। एक थ्रेड हजारों एक साथ खुले कनेक्शन को संभाल सकता है, केवल तभी टास्क स्विच करता है जब वर्तमान टास्क किसी चीज़ का इंतज़ार कर रहा हो (जैसे सॉकेट से पढ़ना)।

Tokio सिर्फ एक लाइब्रेरी नहीं, बल्कि एक पूरी इकोसिस्टम है। इसमें शामिल हैं:

रनटाइम — टास्क शेड्यूलर और इवेंट ड्राइवर (epoll/kqueue/IOCP)
स्टैंडर्ड नेटवर्क प्रोटोकॉल — TCP, UDP, Unix sockets
टाइमर — sleep, interval, deadline
सिंक्रोनाइज़ेशन — async कोड के लिए mutex, semaphore, barrier
फ़ाइल I/O — फ़ाइलों का asynchronous पढ़ना/लिखना
यूटिलिटीज़ — चैनल (mpsc, oneshot, broadcast), बफ़र, कोडेक

Tokio कई प्रसिद्ध प्रोजेक्ट्स की नींव है, जैसे वेब फ्रेमवर्क Axum, HTTP क्लाइंट Reqwest, वेब सॉकेट Tungstenite, डेटाबेस SQLx और कई अन्य।

इंस्टॉलेशन

Python (pip) या Node.js (npm) के विपरीत, Rust पैकेज सिस्टम Cargo का उपयोग करता है। Tokio इंस्टॉल करने के लिए, Cargo.toml फ़ाइल में डिपेंडेंसी जोड़ें:

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

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

[dependencies]
tokio = { version = "1", features = ["rt", "macros", "net", "io-util", "time", "sync"] }

मुख्य फ़ीचर:

rt — मल्टीथ्रेडेड रनटाइम
macros — मैक्रोज़ #[tokio::main] और tokio::select!
net — TCP, UDP, Unix sockets
io-util — asynchronous Reader/Writer
time — टाइमर और sleep
sync — सिंक्रोनाइज़ेशन प्रिमिटिव
fs — फ़ाइल सिस्टम के साथ asynchronous काम
process — कमांड का asynchronous लॉन्च
signal — OS सिग्नल हैंडलिंग

त्वरित शुरुआत

चलिए एक सरल HTTP सर्वर बनाते हैं जो हर अनुरोध पर "Hello, World!" का जवाब देता है। इसके लिए हमें hyper क्रेट (Tokio के ऊपर HTTP लाइब्रेरी) की भी ज़रूरत होगी:

// Cargo.toml
// [dependencies]
// tokio = { version = "1", features = ["full"] }
// hyper = { version = "1", features = ["server", "http1"] }

use hyper::service::service_fn;
use hyper::{Request, Response, Server};
use hyper::body::Incoming;
use std::convert::Infallible;

async fn handle_request(_req: Request<Incoming>) -> Result<Response<String>, Infallible> {
    Ok(Response::new("Hello, World!".to_string()))
}

#[tokio::main]
async fn main() {
    let addr = ([127, 0, 0, 1], 3000).into();
    let server = Server::bind(&addr).serve(service_fn(handle_request));
    println!("Server running on http://{}", addr);
    if let Err(e) = server.await {
        eprintln!("Server error: {}", e);
    }
}

cargo run चलाएं और ब्राउज़र में http://127.0.0.1:3000 खोलें। आपको "Hello, World!" दिखाई देगा।