सी ++17

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

std::shared_mutex बिल्कुल केह् ऐ ते इसगी C++17 च कीऽ जोड़ेआ गेआ हा?

C++17 थमां पैह् ले, डेवलपर्स गी जिनेंगी पाठक-लेखक शब्दार्थ दी लोड़ ही, गी प्लेटफार्म-विशिष्ट समाधानें जि'यां POSIX सिस्टम पर pthread_rwlock_t जां Windows पर SRWLOCK पर भरोसा करना पौंदा हा, नेईं ते ओह् त्रीए-पक्ष लाइब्रेरी दा इस्तेमाल करदे हे जि'यां Boost. C++17 मानक समिति ने इस अंतराल गी पन्छानेआ ते इसगी सीधे संबोधित करने आस्तै हेडर च std::shared_mutex पेश कीता.

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

एह् दोहरी-मोड डिजाइन std::shared_mutex गी कैशे, कॉन्फ़िगरेशन रजिस्ट्री, ते कुसै बी डेटा संरचना जनेह् परिदृश्यें आस्तै इक प्राकृतिक फिट बनांदा ऐ जित्थै रीड्स वर्कलोड पर हावी होंदे न.

तुस टिप्पणियें कन्नै असली कोड च std::shared_mutex दा इस्तेमाल किस चाल्ली करदे ओ?

कोड च टिप्पणियां जेह् ड़ियां std::shared_mutex दा इस्तेमाल करदियां न, खास तौर उप्पर कीमती न कीजे समवर्ती तर्क दे बारे च तर्क करना बदनाम ऐ. अच्छी तरह कन्नै रक्खी गेदी टिप्पणियां इस गल्लै गी स्पश्ट करदियां न जे क्यो इक खास लॉक प्रकार चुनेआ गेआ हा, जेह् ड़ा भविक्ख दे रखरखाव करने आह् लें गी गलती कन्नै डेटा दौड़ शुरू करने दे जोखिम गी नाटकीय रूप कन्नै घट्ट करदा ऐ। इत्थें इक ठेठ पैटर्न ऐ:

 # <साझा_म्यूटेक्स> शामिल करो
#<अनक्रमित_नक्शा> शामिल करो
# <स्ट्रिंग> शामिल करो

class कॉन्फ़िगर रजिस्ट्री {
    परिवर्तनशील एसटीडी::साझा_म्यूटेक्स एमटीएक्स_; // निचले नक्शे दी रक्षा करदा ऐ
    std::unordered_map  डेटा_;

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

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

ध्यान देओ जे टिप्पणियां सिर्फ कोड कीऽ करदा ऐ उसी दोबारा दस्सने दे बजाय हर लॉक चयन दे पिच्छें दे इरादे गी किस चाल्ली समझा करदियां न। एह् स्वर्ण मानक ऐ: टिप्पणियें गी क्यों दा जवाब देना चाहिदा, न कि क्या। म्यूटेक्स पर 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 ते दिक्खो किस चाल्ली इक इकाई प्रणाली तुंदी टीम दे कम्म करने दे तरीके गी बदलदी ऐ।