C++17 இலிருந்து std::shared_mutex புரிந்துகொள்வது

std::shared_mutex, C++17 இல் அறிமுகப்படுத்தப்பட்டது, எழுதும் செயல்பாடுகளுக்கான பிரத்யேக அணுகலை உறுதி செய்யும் போது, பல இழைகள் ஒரே நேரத்தில் பகிரப்பட்ட (படிக்க) பூட்டுகளை வைத்திருக்க அனுமதிக்கும் பழமையான ஒத்திசைவு ஆகும். மூன்றாம் தரப்பு நூலகங்கள் அல்லது இயங்குதளம் சார்ந்த APIகளை அடையாமல், வாசகர்-எழுத்தாளர் பூட்டுதலைச் செயல்படுத்த டெவலப்பர்களுக்கு சுத்தமான, நிலையான வழியை வழங்குவதன் மூலம், நவீன C++ இல் உள்ள பொதுவான ஒத்திசைவு சவால்களில் ஒன்றை இது தீர்க்கிறது.

std::shared_mutex என்றால் என்ன மற்றும் அது ஏன் C++17 இல் சேர்க்கப்பட்டது?

C++17 க்கு முன், வாசகர்-எழுத்தாளர் சொற்பொருள் தேவைப்படும் டெவலப்பர்கள், POSIX சிஸ்டங்களில் pthread_rwlock_t அல்லது Windows இல் SRWLOCK போன்ற இயங்குதளம் சார்ந்த தீர்வுகளை நம்பியிருக்க வேண்டும் அல்லது பூஸ்ட் போன்ற மூன்றாம் தரப்பு நூலகங்களைப் பயன்படுத்துவார்கள். C++17 ஸ்டாண்டர்ட் கமிட்டி இந்த இடைவெளியை அங்கீகரித்து அதை நேரடியாக நிவர்த்தி செய்ய std::shared_mutex தலைப்பில் அறிமுகப்படுத்தப்பட்டது.

முக்கிய யோசனை நேரடியானது: பல நிஜ உலக நிரல்களில், தரவு எழுதப்பட்டதை விட அடிக்கடி படிக்கப்படுகிறது. ஒரு நிலையான std::mutex அனைத்து அணுகலையும் வரிசைப்படுத்துகிறது — படிக்கப்பட்டவை அடங்கும் — இது தேவையற்ற இடையூறுகளை உருவாக்குகிறது. std::shared_mutex இரண்டு பூட்டுதல் முறைகளை வேறுபடுத்துவதன் மூலம் அந்த கட்டுப்பாட்டை நீக்குகிறது:

• பகிரப்பட்ட (படிக்க) பூட்டு — lock_shared() மூலம் பெறப்பட்டது; பல நூல்கள் இதை ஒரே நேரத்தில் வைத்திருக்க முடியும், இது ஒரே நேரத்தில் படிக்க ஏற்றதாக இருக்கும்.
• பிரத்தியேகமான (எழுத) பூட்டு — lock() மூலம் பெறப்பட்டது; ஒரு நேரத்தில் ஒரே ஒரு நூல் மட்டுமே இதை வைத்திருக்க முடியும், மேலும் இது வைத்திருக்கும் போது பகிரப்பட்ட பூட்டுகள் அனுமதிக்கப்படாது.
• std::shared_lock — கட்டுமானத்தில் lock_shared() மற்றும் அழிவின் போது unlock_shared() என்று அழைக்கும் RAII ரேப்பர், வள கசிவுகளைத் தடுக்கிறது.
• std::unique_lock / std::lock_guard — பிரத்தியேக பயன்முறையில் பயன்படுத்தப்படுகிறது, எழுதும் செயல்பாடுகள் முழுமையாக பாதுகாக்கப்படுவதையும் விதிவிலக்கு-பாதுகாப்பாக இருப்பதையும் உறுதி செய்கிறது.

இந்த இரட்டைப் பயன்முறை வடிவமைப்பு std::shared_mutex தற்காலிகச் சேமிப்புகள், உள்ளமைவுப் பதிவேடுகள் மற்றும் வாசிப்புகள் பணிச்சுமையில் ஆதிக்கம் செலுத்தும் தரவுக் கட்டமைப்பு போன்றவற்றுக்கு இயல்பான பொருத்தமாக அமைகிறது.

கருத்துகளுடன் உண்மையான குறியீட்டில் std::shared_mutex ஐ எவ்வாறு பயன்படுத்துகிறீர்கள்?

std::shared_mutex ஐப் பயன்படுத்தும் குறியீட்டில் உள்ள கருத்துகள் குறிப்பாக மதிப்புமிக்கவை, ஏனெனில் ஒத்திசைவு தர்க்கம் நியாயப்படுத்துவது மிகவும் கடினம். ஒரு குறிப்பிட்ட பூட்டு வகை தேர்ந்தெடுக்கப்பட்டது ஏன் என்பதை நன்கு இடப்பட்ட கருத்துகள் தெளிவுபடுத்துகின்றன, இது எதிர்கால பராமரிப்பாளர்கள் தற்செயலாக தரவு பந்தயங்களை அறிமுகப்படுத்தும் அபாயத்தை வியத்தகு முறையில் குறைக்கிறது. இதோ ஒரு பொதுவான பேட்டர்ன்:

#include 
#அடங்கும் <வரிசைப்படுத்தப்படாத_வரைபடம்>
# அடங்கும்

class ConfigRegistry {
    mutable std::shared_mutex mtx_; // கீழே உள்ள வரைபடத்தைப் பாதுகாக்கிறது
    std::unordered_map data_;

பொது:
    // படிக்கும் பாதை: பல திரிகள் இதை ஒரே நேரத்தில் அழைக்கலாம்
    std::string get(const std::string& key) const {
        std::shared_lock lock(mtx_); // பகிரப்பட்ட பூட்டு — ஒரே நேரத்தில் படிக்க பாதுகாப்பானது
        தானியங்கு அது = data_.find(key);
        அதை திருப்பி != data_.end() ? அது->இரண்டாவது : "";
    }

    // எழுதும் பாதை: பிரத்தியேக அணுகல் தேவை
    void set(const std::string& key, const std::string& val) {
        std::unique_lock lock(mtx_); // பிரத்தியேக பூட்டு - அனைத்து வாசகர்களையும் தடுக்கிறது
        தரவு_[விசை] = மதிப்பு;
    }
};

குறியீடு என்ன செய்கிறது என்பதை மறுபரிசீலனை செய்வதற்குப் பதிலாக, ஒவ்வொரு பூட்டுத் தேர்வின் பின்னுள்ள நோக்கத்தையும் கருத்துகள் எவ்வாறு விளக்குகின்றன என்பதைக் கவனியுங்கள். இது தங்கத் தரநிலை: கருத்துகள் ஏன் என்பதற்கு பதிலளிக்க வேண்டும், என்ன அல்ல. மியூடெக்ஸில் உள்ள mutable திறவுச்சொல், get() ஐப் பூட்ட இயலும் போது const என்று அறிவிக்க அனுமதிக்கிறது, இது ஒரு பொதுவான மற்றும் idiomatic pattern.

முக்கிய நுண்ணறிவு: எப்போதும் RAII லாக் ரேப்பர்களைப் பயன்படுத்தவும் (std::shared_lock, std::unique_lock) std::shared_mutex — ஒருபோதும் lock() என்று அழைக்க வேண்டாம். விதிவிலக்குகளின் முன்னிலையில் கைமுறையாகப் பூட்டுவது முட்டுக்கட்டைகள் மற்றும் வரையறுக்கப்படாத நடத்தைக்கான உத்தரவாதமான பாதையாகும்.

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::condition_variable உடன் பயன்படுத்த std::shared_mutex பாதுகாப்பானதா?

std::condition_variableக்கு std::unique_lock தேவைப்படுகிறது, எனவே இது std::shared_mutex உடன் நேரடியாக இணங்கவில்லை. பகிரப்பட்ட மியூடெக்ஸை வைத்திருக்கும் போது நிபந்தனையின் பேரில் நீங்கள் காத்திருக்க வேண்டியிருந்தால், std::condition_variable_any ஐப் பயன்படுத்தவும், இது std::shared_mutex std::shared_lock உடன் இணைக்கப்பட்டது உட்பட எந்த BasicLockable வகையிலும் வேலை செய்கிறது.

நான் std::shared_mutex ஐப் பயன்படுத்தும் ஒவ்வொரு முறையும் கருத்துகளைச் சேர்க்க வேண்டுமா?

குறைந்தபட்சம், அது எந்தத் தரவைப் பாதுகாக்கிறது மற்றும் அது பராமரிக்கும் மாறுபாடுகளை விவரிக்க, மியூடெக்ஸின் அறிவிப்பில் கருத்துத் தெரிவிக்கவும். ஒவ்வொரு பூட்டு தளத்திலும், பகிரப்பட்ட மற்றும் பிரத்தியேக அணுகல் ஏன் தேர்ந்தெடுக்கப்பட்டது என்பதை விளக்கும் சுருக்கமான கருத்து, குறியீடு மதிப்பாய்வாளர்கள் மற்றும் எதிர்கால பராமரிப்பாளர்களுக்கு குறிப்பிடத்தக்க மதிப்பைச் சேர்க்கிறது. ஒத்திசைவு பிழைகள் இனப்பெருக்கம் செய்வதற்கும் சரிசெய்வதற்கும் கடினமானவையாகும், எனவே தெளிவான, துல்லியமான கருத்துகளில் முதலீடு பல மடங்கு ஈவுத்தொகையை செலுத்துகிறது.

சிக்கலான அமைப்புகளை நிர்வகித்தல் - ஒரே நேரத்தில் C++ குறியீடு அல்லது முழு வணிகச் செயல்பாடு - சரியான கருவிகள் மற்றும் தெளிவான கட்டமைப்பைக் கோருகிறது. Mewayz என்பது 138,000 க்கும் மேற்பட்ட பயனர்களால் நம்பப்படும் 207-தொகுதி வணிக OS ஆகும், இது மார்க்கெட்டிங், CRM, இ-காமர்ஸ், பகுப்பாய்வு மற்றும் பலவற்றில் ஒரே மாதிரியான தெளிவைக் கொண்டுவருகிறது, இவை அனைத்தும் ஒரே தளத்தில் மாதத்திற்கு $19 இல் தொடங்குகிறது. டஜன் கணக்கான துண்டிக்கப்பட்ட கருவிகளை ஏமாற்றுவதை நிறுத்திவிட்டு, நன்கு வடிவமைக்கப்பட்ட மென்பொருளின் துல்லியத்துடன் உங்கள் வணிகத்தை இயக்கத் தொடங்குங்கள். இன்றே app.mewayz.com இல் Mewayz ஐ முயற்சிக்கவும் மற்றும் உங்கள் குழு செயல்படும் விதத்தை ஒரு ஒருங்கிணைந்த அமைப்பு எவ்வாறு மாற்றுகிறது என்பதைப் பார்க்கவும்.