parking_lot for Rust: तेज़ सिंक्रोनाइज़ेशन प्रिमिटिव

parking_lot लाइब्रेरी Rust भाषा के लिए सबसे लोकप्रिय और परफॉर्मेंट सिंक्रोनाइज़ेशन प्रिमिटिव में से एक है। यह स्टैंडर्ड म्यूटेक्स (std::sync::Mutex), रीड-राइट लॉक (std::sync::RwLock) और कंडीशनल वेरिएबल (std::sync::Condvar) का एक बेहतरीन विकल्प प्रदान करती है, जो काफी बेहतर परफॉर्मेंस और छोटे कोड साइज़ के साथ आती है।

इस लाइब्रेरी की ज़रूरत क्यों है? Rust के स्टैंडर्ड सिंक्रोनाइज़ेशन प्रिमिटिव सुरक्षित तो हैं, लेकिन उनमें कुछ कमियाँ हैं: वे साधारण मामलों में भी सिस्टम कॉल (Linux पर futex) का उपयोग करते हैं, फ़्लैग्स के लिए अतिरिक्त मेमोरी लेते हैं, और इनका आंतरिक कार्यान्वयन जटिल होता है। parking_lot इन समस्याओं को अधिक कुशल एल्गोरिदम (जैसे ऑप्टिमिस्टिक लॉक और स्पिन-लूप) का उपयोग करके हल करती है और ओवरहेड को कम करती है। नतीजतन, कोड तेज़ चलता है, खासकर हाई-कंटेंशन वाले मल्टीथ्रेडेड एप्लिकेशन में।

यह लाइब्रेरी Rust के साथ पूरी तरह से संगत है और उपयोगकर्ता को unsafe कोड की आवश्यकता नहीं है। यह स्टैंडर्ड लाइब्रेरी के समान इंटरफ़ेस प्रदान करती है, लेकिन अतिरिक्त सुविधाओं के साथ: टाइमआउट सपोर्ट वाला Mutex, फेयर क्यू वाला RwLock, लेज़ी इनिशियलाइज़ेशन के लिए Once और रीएंट्रेंट लॉक के लिए ReentrantMutex। parking_lot वेब सर्वर से लेकर गेम इंजन तक, हाई-परफॉर्मेंस Rust एप्लिकेशन के लिए डी-फैक्टो स्टैंडर्ड है।

इंस्टॉलेशन

अपने प्रोजेक्ट के Cargo.toml फ़ाइल में लाइब्रेरी जोड़ें:

[dependencies]
parking_lot = "0.12"

फिर यह कमांड चलाएँ:

cargo build

या, यदि आप cargo add (Rust 1.62 से) का उपयोग कर रहे हैं:

cargo add parking_lot

इसके बाद, आप लाइब्रेरी से प्रिमिटिव इम्पोर्ट कर सकते हैं:

use parking_lot::{Mutex, RwLock, Condvar, Once, ReentrantMutex};

त्वरित शुरुआत: न्यूनतम कार्यशील उदाहरण

यहाँ मल्टीथ्रेडेड वातावरण में एक सामान्य काउंटर को सुरक्षित करने के लिए parking_lot के Mutex का एक सरल उदाहरण है:

use parking_lot::Mutex;
use std::thread;

fn main() {
    // म्यूटेक्स बनाएँ जो एक वैल्यू को रैप करता है
    let counter = Mutex::new(0);

    // 10 थ्रेड बनाएँ, प्रत्येक काउंटर को 1 से बढ़ाता है
    let mut handles = vec![];
    for _ in 0..10 {
        let handle = thread::spawn(|| {
            // लॉक प्राप्त करें — .lock() RAII-गार्ड लौटाता है
            let mut guard = counter.lock();
            *guard += 1;
            // guard स्वचालित रूप से स्कोप से बाहर निकलने पर रिलीज़ हो जाता है
        });
        handles.push(handle);
    }

    // सभी थ्रेड के पूरा होने की प्रतीक्षा करें
    for handle in handles {
        handle.join().unwrap();
    }

    // अंतिम मान पढ़ें
    let final_value = *counter.lock();
    println!("अंतिम मान: {}", final_value); // 10 होना चाहिए
}

इस उदाहरण में, counter.lock() एक MutexGuard लौटाता है, जो नष्ट होने पर स्वचालित रूप से लॉक को रिलीज़ करता है। स्टैंडर्ड std::sync::Mutex के विपरीत, यहाँ एरर (poisoning) को हैंडल करने की ज़रूरत नहीं है — parking_lot डिफ़ॉल्ट रूप से पैनिक होने पर म्यूटेक्स को पॉइज़न नहीं करता।

मुख्य तरीके और प्रकार

नीचे parking_lot लाइब्रेरी के 8 मुख्य तरीकों/प्रकारों को सिग्नेचर, विवरण और उदाहरणों के साथ दिया गया है।

1. Mutex::lock()

सिग्नेचर: pub fn lock(&self) -> MutexGuard<'_, T>

विवरण: म्यूटेक्स को लॉक करता है, वर्तमान थ्रेड को तब तक ब्लॉक करता है जब तक लॉक प्राप्त न हो जाए। एक RAII-गार्ड लौटाता है जो स्कोप से बाहर निकलने पर स्वचालित रूप से लॉक रिलीज़ करता है।

use pa