C++17 မှ std::shared_mutex နားလည်မှု

std::shared_mutex သည် C++17 တွင် မိတ်ဆက်ခဲ့သည်၊ သည် စာတွဲများစွာကို တစ်ပြိုင်နက်တည်း မျှဝေထားသော (ဖတ်ရန်) လော့ခ်များကို ထိန်းထားနိုင်စေသည့် ထပ်တူပြုမှုဆိုင်ရာ primitive တစ်ခုဖြစ်သည်။ ၎င်းသည် ပြင်ပအဖွဲ့အစည်း စာကြည့်တိုက်များ သို့မဟုတ် ပလပ်ဖောင်းအလိုက် API များကို လက်လှမ်းမမီဘဲ စာဖတ်သူ-စာရေးဆရာသော့ခတ်ခြင်းအား အကောင်အထည်ဖော်ရန် သန့်ရှင်းသပ်ရပ်သော စံနည်းလမ်းတစ်ခုအား developer များအား ပေးခြင်းဖြင့် ခေတ်မီ C++ တွင် အဖြစ်များဆုံးသော စိန်ခေါ်မှုများကို ဖြေရှင်းပေးပါသည်။

အတိအကျဆိုတာ std::shared_mutex ဖြစ်ပြီး ဘာကြောင့် C++17 မှာ ထည့်ထားတာလဲ။

C++17 မတိုင်မီ၊ စာဖတ်သူ-စာရေးဆရာ၏ အဓိပ္ပါယ်ဖွင့်ဆိုချက်များ လိုအပ်သော developer များသည် POSIX စနစ်များ သို့မဟုတ် SRWLOCK ကဲ့သို့သော ပလပ်ဖောင်းဆိုင်ရာ ဖြေရှင်းချက်များအား POSIX စနစ်များ သို့မဟုတ် SRWLOCK ကဲ့သို့သော ပလပ်ဖောင်းအလိုက် ဖြေရှင်းချက်များကို အားကိုးခဲ့ရသည်၊ သို့မဟုတ် ၎င်းတို့သည် Boost ကဲ့သို့သော ပြင်ပကုမ္ပဏီစာကြည့်တိုက်များကို အသုံးပြုမည်ဖြစ်သည်။ C++17 စံကော်မတီသည် ဤကွာဟချက်ကို အသိအမှတ်ပြုပြီး ၎င်းကို တိုက်ရိုက်ဖြေရှင်းရန်အတွက် std::shared_mutex အား ခေါင်းစီးတွင် မိတ်ဆက်ပေးခဲ့သည်။

အဓိက အယူအဆသည် ရိုးရှင်းသည်- လက်တွေ့ကမ္ဘာ ပရိုဂရမ်များစွာတွင်၊ ဒေတာကို ရေးသားထားသည်ထက် ပိုမိုမကြာခဏ ဖတ်ရှုပါသည်။ စံသတ်မှတ်ချက်တစ်ခုသည် std::mutex သည် ဝင်ရောက်ခွင့်အားလုံးကို အမှတ်အသားပြုသည် — ပါ၀င်သည် — မလိုအပ်သော ပိတ်ဆို့မှုများကို ဖန်တီးပေးသည်။ std::shared_mutex သည် လော့ခ်ချခြင်းမုဒ်နှစ်ခုကြားကို ပိုင်းခြားခြင်းဖြင့် အဆိုပါကန့်သတ်ချက်ကို ရုတ်သိမ်းသည်-

• မျှဝေထားသည် (ဖတ်ရန်) လော့ခ်ချခြင်း — lock_shared() မှတဆင့် ရယူခဲ့သည်။ စာတွဲများစွာသည် ၎င်းကို တစ်ပြိုင်နက်တည်း ထိန်းထားနိုင်ပြီး ၎င်းကို တစ်ပြိုင်နက်ဖတ်ရှုရန်အတွက် စံပြဖြစ်စေသည်။
• သီးသန့် (ရေးရန်) လော့ခ်ချခြင်း — lock() မှတဆင့် ရယူခဲ့သည်။ တစ်ကြိမ်လျှင် စာတွဲတစ်ခုသာ ထိန်းထားနိုင်ပြီး ၎င်းကို ထိန်းသိမ်းထားစဉ် မျှသုံးသောသော့များကို ခွင့်မပြုပါ။
• std::shared_lock — တည်ဆောက်မှုတွင် lock_shared() ဟုခေါ်သော RAII ထုပ်ပိုးပြီး ဖျက်ဆီးခြင်းတွင် unlock_shared() ကို ဖျက်စီးခြင်းဖြင့် အရင်းအမြစ်များ ပေါက်ကြားခြင်းကို ကာကွယ်ပေးပါသည်။
• std::unique_lock / std::lock_guard — သီးသန့်မုဒ်ဖြင့် အသုံးပြုပြီး စာရေးခြင်းလုပ်ငန်းကို အပြည့်အဝကာကွယ်ပြီး ချွင်းချက်-ဘေးကင်းကြောင်း သေချာစေပါသည်။

ဤ dual-mode ဒီဇိုင်းသည် std::shared_mutex ကို cache၊ configuration registries နှင့် workload ကို လွှမ်းမိုးထားသည့် မည်သည့် data structure ကဲ့သို့သော အခြေအနေများအတွက်မဆို သဘာဝအတိုင်း အံဝင်ခွင်ကျဖြစ်စေသည်။

မှတ်ချက်များနှင့်အတူ အစစ်အမှန်ကုဒ်တွင် std::shared_mutex ကို သင်မည်သို့အသုံးပြုသနည်း။

std::shared_mutex ကို အသုံးပြုသည့် ကုဒ်ရှိ မှတ်ချက်များသည် အထူးတန်ဖိုးရှိသောကြောင့် ဆက်စပ်ယုတ္တိဗေဒသည် ကျိုးကြောင်းဆင်ခြင်ရန် ခက်ခဲသော နာမည်ဆိုးဖြင့် ကျော်ကြားသောကြောင့် ဖြစ်သည်။ ကောင်းစွာထည့်သွင်းထားသောမှတ်ချက်များသည် အဘယ်ကြောင့် သီးခြားသော့ခတ်အမျိုးအစားကို ရွေးချယ်ထားကြောင်း ရှင်းလင်းစေပြီး၊ ဒေတာပြိုင်ပွဲများကို အနာဂတ်ထိန်းသိမ်းသူများသည် မတော်တဆမိတ်ဆက်ခြင်းအန္တရာယ်ကို သိသိသာသာလျှော့ချပေးသည်။ ဤသည်မှာ ပုံမှန်ပုံစံဖြစ်သည်-

#include 
#include 
#ပါဝင်သည် 

အတန်းအစား ConfigRegistry {
    ပြောင်းလဲနိုင်သော std::shared_mutex mtx_; // အောက်ဖော်ပြပါမြေပုံကို ကာကွယ်သည်။
    std::unordered_map data_;

အများသူငှာ-
    // လမ်းကြောင်းကိုဖတ်ပါ- စာတွဲများစွာသည် ၎င်းကို တစ်ပြိုင်နက်ခေါ်ဆိုနိုင်သည်။
    std::string get(const std::string&key) const {
        std::shared_lock လော့ခ်(mtx_); // မျှဝေထားသောသော့ခတ် — တစ်ပြိုင်နက်ဖတ်ရှုရန်အတွက် ဘေးကင်းသည်။
        အလိုအလျောက် = data_.find(key);
        != data_.end() ? it->ဒုတိယ : "";
    }

    // လမ်းကြောင်းရေးသားရန်- သီးသန့်ဝင်ရောက်ခွင့် လိုအပ်သည်။
    void set(const std::string&key၊ const std::string&val) {
        std::unique_lock သော့(mtx_); // သီးသန့်သော့ခတ်သည် — စာဖတ်သူအားလုံးကို ပိတ်ဆို့သည်။
        data_[သော့] = val;
    }
};

ကုဒ်လုပ်သည်ကို ပြန်လည်ဖော်ပြခြင်းထက် လော့ခ်ရွေးချယ်မှုတစ်ခုစီ၏ နောက်ကွယ်ရှိ ရည်ရွယ်ချက်ကို မှတ်ချက်များက မည်သို့ရှင်းပြသည်ကို သတိပြုပါ။ ဤသည်မှာ ရွှေစံနှုန်းဖြစ်သည်- မှတ်ချက်များသည် ဘာကြောင့်၊ ဘာ မဟုတ်ပါ။ mutex ပေါ်ရှိ mutable သော့ချက်စကားလုံးသည် get() အား လော့ခ်ချနိုင်ဆဲဖြစ်ပြီး၊ သာမန်နှင့် idiomatic ပုံစံဖြစ်သည်။

သော့ထိုးထွင်းသိမြင်မှု- RAII လော့ခ်ထုပ်ပါများ (std::shared_lock၊ std::unique_lock) ဖြင့် std::shared_mutex — — 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 ဂရုတစိုက်မှတ်ဉာဏ်အမိန့်ပေးခြင်းနှင့် ပေါင်းစပ်ခြင်းသည် တစ်ခါတစ်ရံတွင် ရိုးရှင်းသောအလံများ သို့မဟုတ် ကောင်တာများအတွက် mutex ကို လုံးလုံးအစားထိုးနိုင်သော်လည်း ရှုပ်ထွေးသောဒေတာဖွဲ့စည်းပုံများအတွက် std::shared_mutex သည် စံစာကြည့်တိုက်တွင် ဖတ်ရလွယ်ကူပြီး ထိန်းသိမ်းနိုင်သော အကောင်းဆုံးဖြေရှင်းချက်ဖြစ်နေဆဲဖြစ်သည်။

အမေးများသောမေးခွန်းများ

std::shared_mutex သည် ငတ်မွတ်မှုကို ဖြစ်စေနိုင်ပါသလား။

ဟုတ်ကဲ့၊ ရပါတယ်။ မျှသုံးလော့ခ်ကိုင်ဆောင်ထားသူအသစ်များ ဆက်တိုက်ရောက်ရှိလာပါက၊ သီးသန့်သော့ခတ်တောင်းဆိုသူသည် အကန့်အသတ်မရှိစောင့်ဆိုင်းနိုင်သည် — ဂန္တဝင် စာရေးဆရာငတ်မွတ်ခြင်း ပြဿနာ။ C++ စံနှုန်းသည် တိကျသော တရားမျှတမှုမူဝါဒကို ပြဌာန်းထားခြင်း မရှိသောကြောင့် အပြုအမူ အကောင်အထည်ဖော်မှုအပေါ် မူတည်ပါသည်။ လက်တွေ့တွင်၊ စံပြစာကြည့်တိုက် အကောင်အထည်ဖော်မှုအများစုသည် ၎င်းတို့ကို တန်းစီစောင့်ဆိုင်းပြီးသည်နှင့် သီးသန့်သော့ခလောက်များကို ဦးစားပေးလုပ်ဆောင်သည်၊ သို့သော် ထုတ်လုပ်မှုတွင် ငတ်မွတ်မှုမှာ စိုးရိမ်စရာဖြစ်ပါက ၎င်းကို သင်၏ သီးခြား toolchain နှင့် platform အတွက် အတည်ပြုသင့်ပါသည်။

std::shared_mutex ကို std::condition_variable ဖြင့် အသုံးပြုရန် ဘေးကင်းပါသလား။

std::condition_variable std::unique_lock လိုအပ်သောကြောင့် std::shared_mutex နှင့် တိုက်ရိုက် တွဲဖက်၍မရပါ။ မျှဝေထားသော mutex ကိုကိုင်ထားစဉ် အခြေအနေတစ်ခုပေါ်တွင် စောင့်ဆိုင်းရန် လိုအပ်ပါက၊ std::shared_lock နှင့် တွဲဖက်ထားသည့် std::shared_mutex အပါအဝင် မည်သည့် BasicLockable အမျိုးအစားနှင့်မဆို လုပ်ဆောင်နိုင်သော std::shared_lock ကို အသုံးပြုပါ။

std::shared_mutex ကိုသုံးတိုင်း မှတ်ချက်များ ထည့်သင့်သလား။

အနည်းဆုံး၊ ၎င်းသည် မည်သည့်ဒေတာကို ကာကွယ်ပေးသည်နှင့် ၎င်းတွင် ထိန်းသိမ်းထားသည့် ပုံစံကွဲများကို ဖော်ပြရန် mutex ၏ ကြေငြာချက်ကို မှတ်ချက်ပေးပါ။ လော့ခ်ချသည့်ဆိုက်တစ်ခုစီတွင်၊ အဘယ်ကြောင့် မျှဝေအသုံးပြုခြင်းနှင့် သီးသန့်အသုံးပြုခွင့်ကို ရွေးချယ်ရခြင်းအကြောင်း ရှင်းပြထားသည့် အတိုချုံးမှတ်ချက်သည် ကုဒ်သုံးသပ်သူများနှင့် အနာဂတ်ထိန်းသိမ်းသူများအတွက် သိသာထင်ရှားသောတန်ဖိုးကို ပေါင်းထည့်သည်။ ထပ်တူကျသော ချို့ယွင်းချက်များသည် ပြန်လည်ထုတ်လုပ်ရန်နှင့် ပြုပြင်ရန် အခက်ခဲဆုံးများထဲမှ တစ်ခုဖြစ်သောကြောင့် ရှင်းလင်းပြတ်သားသော တိကျသောမှတ်ချက်များတွင် ရင်းနှီးမြှုပ်နှံမှုသည် အမြတ်ဝေစုများကို အဆများစွာပေးသည်။

ရှုပ်ထွေးသောစနစ်များကို စီမံခန့်ခွဲခြင်း—တစ်ပြိုင်တည်း C++ ကုဒ် သို့မဟုတ် လုပ်ငန်းလည်ပတ်မှုတစ်ခုလုံးဖြစ်စေ — မှန်ကန်သောကိရိယာများနှင့် ရှင်းလင်းသောဖွဲ့စည်းပုံတို့ကို တောင်းဆိုသည်။ Mewayz သည် စျေးကွက်ချဲ့ထွင်ခြင်း၊ CRM၊ e-commerce၊ ခွဲခြမ်းစိတ်ဖြာခြင်းနှင့် အခြားအရာများကို တစ်လလျှင် $19 မှစတင်၍ ပလပ်ဖောင်းတစ်ခုတည်းတွင် တူညီသောရှင်းလင်းမှုကို ယူဆောင်လာစေရန် သုံးစွဲသူ 138,000 ကျော်က ယုံကြည်စိတ်ချရသော 207-module လုပ်ငန်း OS ဖြစ်သည်။ ချိတ်ဆက်မှုပြတ်တောက်နေသော ကိရိယာများစွာကို တီးခတ်နေခြင်းကို ရပ်လိုက်ပြီး တိကျကောင်းမွန်သော ဒီဇိုင်းထုတ်ထားသော ဆော့ဖ်ဝဲဖြင့် သင့်လုပ်ငန်းကို စတင်လိုက်ပါ။ ဒီနေ့ Mewayz ကို app.mewayz.com မှာ စမ်းသုံးကြည့်ပြီး တစ်စုတစ်စည်းတည်းစနစ်က သင့်အဖွဲ့အလုပ်လုပ်ပုံ ပြောင်းလဲပုံကို ကြည့်လိုက်ပါ။