C++17 से std::shared_mutex के समझल जा रहल बा

std::shared_mutex, C++17 में पेश कइल गइल, एगो सिंक्रनाइजेशन प्रिमिटिव हवे जे कई थ्रेड सभ के एक साथ साझा (पढ़ल) लॉक सभ के रखे के इजाजत देला जबकि लिखे के ऑपरेशन खातिर बिसेस पहुँच सुनिश्चित करे ला। ई आधुनिक C++ में सभसे आम समवर्ती चुनौती सभ में से एक के हल करे ला आ डेवलपर लोग के एगो साफ, मानक तरीका दे के रीडर-राइटर लॉकिंग के लागू करे के बिना थर्ड पार्टी लाइब्रेरी भा प्लेटफार्म-बिसेस एपीआई सभ के ओर पहुँचले।

std::shared_mutex ठीक से का ह आ एकरा के C++17 में काहे जोड़ल गइल?

C++17 से पहिले, डेवलपर लोग के जिनहन के रीडर-राइटर सिमेंटिक्स के जरूरत रहे, प्लेटफार्म-बिसेस समाधान पर निर्भर रहे के पड़े जइसे कि pthread_rwlock_t जइसे कि POSIX सिस्टम पर या SRWLOCK विंडोज पर, ना त ऊ लोग बूस्ट नियर थर्ड पार्टी लाइब्रेरी सभ के इस्तेमाल करी। C++17 मानक समिति एह अंतर के पहिचान कइलस आ एकरा के सीधे संबोधित करे खातिर हेडर में std::shared_mutex के शुरूआत कइलस।

मूल बिचार सीधा बा: कई ठे वास्तविक दुनिया के प्रोग्राम सभ में, डेटा के लिखल जाए से कहीं ढेर बेर पढ़ल जाला। एगो मानक std::mutex सभ पहुँच के सीरियलाइज करे ला — रीड्स शामिल बा — जे बेमतलब के अड़चन पैदा करे ला। std::shared_mutex दू गो लॉकिंग मोड में अंतर क के ओह प्रतिबंध के उठावे ला:

के बा
• साझा (पढ़ल) लॉक — lock_shared() के माध्यम से हासिल कइल गइल; कई गो थ्रेड एकरा के एक साथ रख सके लें, जेकरा चलते ई एक साथ पढ़े खातिर आदर्श हो जाला।
• विशेष (लिखे) लॉक — lock() के माध्यम से हासिल कइल गइल; एक बेर में खाली एगो धागा एकरा के पकड़ सके ला आ एकरा के पकड़े के दौरान कौनों साझा लॉक के अनुमति ना होला।
• std::shared_lock — एगो RAII रैपर जे निर्माण पर lock_shared() आ नष्ट होखे पर unlock_shared() के कॉल करे ला, संसाधन लीक होखे से रोके ला।
• std::unique_lock / std::lock_guard — एक्सक्लूसिव मोड के साथ इस्तेमाल होला, ई सुनिश्चित करे ला कि लिखे के ऑपरेशन पूरा तरीका से सुरक्षित आ अपवाद-सुरक्षित बा।

ई ड्यूल-मोड डिजाइन std::shared_mutex के कैश, कॉन्फ़िगरेशन रजिस्ट्री, आ कौनों भी डेटा संरचना नियर परिदृश्य सभ खातिर प्राकृतिक फिट बनावे ला जहाँ रीड वर्कलोड पर हावी होखे।

कमेंट के साथ रियल कोड में std::shared_mutex के इस्तेमाल कईसे करीं?

कोड में टिप्पणी जे std::shared_mutex के इस्तेमाल करे लीं, खासतौर पर मूल्यवान होलीं काहें से कि समवर्ती तर्क के बारे में तर्क कइल कुख्यात रूप से मुश्किल बा। बढ़िया से रखल टिप्पणी सभ से ई साफ हो जाला कि काहे कौनों खास लॉक प्रकार के चुनल गइल, जेकरा से भविष्य के रखरखाव करे वाला लोग के गलती से डेटा रेस के सुरुआत करे के जोखिम बहुत कम हो जाला। इहाँ एगो ठेठ पैटर्न बा:

# के शामिल करीं
#<अनऑर्डरड_मैप> शामिल करीं
# के शामिल करीं

क्लास कॉन्फ़िगररजिस्ट्री { 1999 के बा।
    परिवर्तनीय एसटीडी::साझा_म्यूटेक्स एमटीएक्स_; // नीचे दिहल नक्शा के रक्षा करेला
    std::अनऑर्डरड_मैप  डेटा_;

सार्वजनिक बा:
    // पढ़ल पथ: कई गो थ्रेड एकरा के एक साथ कॉल कर सके लें
    std::string get (const std::string& कुंजी) const { 1।
        std::साझा_लॉक लॉक (mtx_) के बा; // साझा लॉक — समवर्ती पढ़े खातिर सुरक्षित
        ऑटो इ = डेटा_.खोज (कुंजी);
        एकरा के वापस करीं != डेटा_.अंत () ? इ->दूसरा : "";
    } 1999 में भइल रहे।

    // लिखे के पथ: अनन्य पहुँच के जरूरत बा
    void सेट (const std:: स्ट्रिंग& कुंजी, const std:: स्ट्रिंग& val) {
        std:: अद्वितीय_लॉक लॉक (mtx_) के बा; // अनन्य ताला — सभ पाठक के अवरुद्ध कर देला
        डेटा_ [कुंजी] = वैल के बा;
    } 1999 में भइल रहे।
};

ध्यान दीं कि टिप्पणी सभ में हर लॉक चुनाव के पीछे के मंशा के कइसे बतावल गइल बा ना कि खाली कोड के काम के दोबारा बतावल गइल। इहे स्वर्ण मानक ह: टिप्पणी के जवाब काहे के चाहीं, ना कि का. म्यूटेक्स पर mutable कीवर्ड get() के const घोषित करे के इजाजत देला जबकि फिर भी लॉक करे में सक्षम बा, ई एगो आम आ मुहावरा वाला पैटर्न हवे।

की इनसाइट: हमेशा std::shared_mutex के साथ RAII लॉक रैपर (std::shared_lock, std::unique_lock) के इस्तेमाल करीं — कबो lock() आ unlock() के मैन्युअल रूप से ना कॉल करीं। अपवाद के मौजूदगी में मैनुअल लॉकिंग गतिरोध आ अपरिभाषित व्यवहार के गारंटी वाला रास्ता हवे।

std::shared_mutex के साथ काम करत समय आम जाल का होला?

साफ टिप्पणी आ बढ़िया नीयत के साथ भी, std::shared_mutex में सूक्ष्म जाल बा जवन अनुभवी डेवलपर लोग के ठेस पहुँचावेला। सबसे खतरनाक बा लॉक अपग्रेड: साझा लॉक के पहिले छोड़ले बिना एक्सक्लूसिव लॉक में अपग्रेड करे के कवनो बिल्ट-इन तरीका नइखे। बिना रिलीज कइले अइसन करे के कोसिस कइला पर तुरंत गतिरोध पैदा हो जाला काहें से कि थ्रेड एक्सक्लूसिव लॉक के इंतजार करत समय साझा लॉक के रखे ला जेकरा के कबो ना दिहल जा सके जबले कि कौनों साझा लॉक मौजूद होखे — जवना में ऊ पकड़ल लॉक भी सामिल बा।

एक अउरी आम गलती गलत दानेदारता के रक्षा कइल बा। डेवलपर लोग कबो-कबो बहुत व्यापक रूप से लॉक क देला, पाठक-लेखक पैटर्न के मकसद के हरा देला, या बहुत संकीर्ण रूप से, अइसन विंडो छोड़ देला जहाँ दू गो अलग-अलग लॉक अधिग्रहण के बीच अपरिवर्तनीय के उल्लंघन होला। खाली लॉक होखे वाला चर के बजाय, अविकारी के संरक्षित कइल जा रहल के वर्णन करे वाली टिप्पणी, कोड समीक्षा के दौरान टीम सभ के सही होखे के बारे में तर्क देवे में मदद करे लीं।

परफॉर्मेंस भी रउआ के हैरान कर सकेला। कई लेखक लोग वाला बहुत बिबाद वाला सिस्टम सभ पर, std::shared_mutex वास्तव में अतिरिक्त बहीखाता ओवरहेड के कारण सादा std::mutex से खराब परफार्मेंस क सकत बा। पाठक-लेखक लॉकिंग के नेट जीत मानला से पहिले हमेशा प्रोफाइल करीं.

std::shared_mutex के तुलना std::mutex आ अन्य विकल्प सभ से कइसे कइल जाला?

std::mutex सरल होला, जब बिबाद कम होखे तब हासिल कइल तेज होला आ जब पढ़ल आ लिखल मोटा-मोटी बराबर आवृत्ति पर होखे तब उचित होला। std::shared_mutex तब चमके ला जब पढ़े के संख्या लिखे से काफी ढेर होला — स्विच पर बिचार करे से पहिले 10:1 या एकरे से ढेर अनुपात एगो उचित नियम हवे।

C++14 std::shared_timed_mutex के सुरुआत कइलस, जवन समय के कोसिस खातिर try_lock_shared_for() आ try_lock_shared_until() जोड़ देला। C++17 के std::shared_mutex एगो दुबला कार्यान्वयन खातिर समयबद्ध वेरिएंट सभ के छोड़ देला। अगर रउआँ के साझा पथ पर समयबद्ध लॉकिंग के जरूरत बा, std::shared_timed_mutex उपलब्ध रही आ दुनों प्रकार पूरा तरीका से मानक बा।

लॉक-फ्री विकल्प सभ खातिर, सावधानीपूर्वक मेमोरी ऑर्डरिंग के साथ मिलल std::atomic कबो-कबो साधारण फ्लैग भा काउंटर सभ खातिर म्यूटेक्स के पूरा तरीका से बदल सके ला, बाकी जटिल डेटा संरचना सभ खातिर, std::shared_mutex मानक लाइब्रेरी में सभसे पठनीय आ रखरखाव करे लायक समाधान बनल रहे ला।

अक्सर पूछल जाए वाला सवाल

का std::shared_mutex भूखमरी के कारण हो सकेला?

हँ, हो सकेला। अगर नया साझा-लॉक धारक लगातार आवत रहेलें, कौनों एक्सक्लूसिव-लॉक अनुरोध करे वाला अनिश्चित काल ले इंतजार क सके ला — एगो क्लासिक लेखक के भूखमरी समस्या। C++ मानक कौनों बिसेस निष्पक्षता नीति के अनिवार्य ना करे ला, एह से व्यवहार लागू करे पर निर्भर करे ला। ब्यवहार में, ज्यादातर मानक लाइब्रेरी कार्यान्वयन एक बेर कतार में खड़ा होखे के बाद लंबित बिसेस लॉक सभ के प्राथमिकता देला, बाकी अगर उत्पादन में भूखमरी चिंता के बिसय होखे तब रउआँ के एकर सत्यापन अपना बिसेस टूलचेन आ प्लेटफार्म खातिर करे के चाहीं।

का std::shared_mutex std::condition_variable के साथ इस्तेमाल करे खातिर सुरक्षित बा?

std::condition_variable खातिर std::unique_lock के जरूरत होला, एह से ई सीधे std::shared_mutex के साथ संगत नइखे। अगर रउआँ के साझा म्यूटेक्स रखत घरी कौनों कंडीशन पर इंतजार करे के जरूरत होखे, std::condition_variable_any के इस्तेमाल करीं, जवन कौनों भी BasicLockable प्रकार के साथ काम करे ला, जवना में std::shared_mutex के जोड़ी std::shared_lock.

का हर बेर जब हम std::shared_mutex के इस्तेमाल करीं त टिप्पणी जोड़ल जाव?

कम से कम, म्यूटेक्स के घोषणा पर टिप्पणी करीं आ ई बताईं कि ई कवन डेटा के सुरक्षा करे ला आ कवन अपरिवर्तनीय सभ के रखरखाव करे ला। हर लॉक साइट पर, एगो संक्षिप्त टिप्पणी जवना में बतावल गइल बा कि साझा बनाम विशेष पहुँच काहे चुनल गइल, कोड समीक्षक आ भविष्य के रखरखाव करे वाला लोग खातिर महत्वपूर्ण मूल्य जोड़ देला। समवर्ती बग सभ के दोबारा बनावल आ ठीक कइल सभसे कठिन बग सभ में से एक हवें, एह से साफ, सटीक टिप्पणी सभ में निवेश से कई गुना लाभांश मिले ला।

जटिल सिस्टम सभ के प्रबंधन — चाहे ऊ समवर्ती C++ कोड होखे भा पूरा बिजनेस ऑपरेशन — सही टूल आ साफ संरचना के जरूरत होला। मेवेज 207 मॉड्यूल वाला बिजनेस ओएस हवे जेकरा पर 138,000 से ढेर यूजर लोग के भरोसा बा कि ऊ मार्केटिंग, सीआरएम, ई-कॉमर्स, एनालिटिक्स आ अउरी कई चीजन में भी इहे स्पष्टता ले आवे ला, ई सभ एकही प्लेटफार्म में महज $19 प्रति महीना से शुरू होला। दर्जनों डिस्कनेक्ट टूल के जुगाड़ कइल बंद करीं आ बढ़िया से डिजाइन कइल सॉफ्टवेयर के परिशुद्धता से आपन बिजनेस चलावल शुरू करीं. आज app.mewayz.com पर मेवेज के आजमाईं आ देखीं कि कइसे एकीकृत सिस्टम राउर टीम के काम करे के तरीका में बदलाव ले आवेला.