ការយល់ដឹង std::shared_mutex ពី C++17

std::shared_mutex ដែលត្រូវបានណែនាំនៅក្នុង C++17 គឺជាការធ្វើសមកាលកម្មបឋមដែលអនុញ្ញាតឱ្យខ្សែស្រឡាយជាច្រើនរក្សាការចាក់សោដែលបានចែករំលែក (អាន) ក្នុងពេលដំណាលគ្នា ខណៈពេលដែលធានាការចូលប្រើផ្តាច់មុខសម្រាប់ប្រតិបត្តិការសរសេរ។ វាដោះស្រាយបញ្ហាប្រឈមមួយក្នុងចំនោមបញ្ហាប្រឈមរួមគ្នាបំផុតនៅក្នុង C++ ទំនើបដោយផ្តល់ឱ្យអ្នកអភិវឌ្ឍន៍នូវវិធីស្តង់ដារស្អាតស្អំដើម្បីអនុវត្តការចាក់សោរអ្នកអានដោយមិនចាំបាច់ចូលទៅកាន់បណ្ណាល័យភាគីទីបី ឬ APIs ជាក់លាក់នៃវេទិកា។

តើអ្វីទៅជា std::shared_mutex ហើយហេតុអ្វីបានជាវាត្រូវបានបន្ថែមនៅក្នុង C++17?

មុននឹង C++17 អ្នកអភិវឌ្ឍន៍ដែលត្រូវការអ្នកអាន-សរសេរអក្សរសាស្ត្រត្រូវពឹងផ្អែកលើដំណោះស្រាយជាក់លាក់នៃវេទិកាដូចជា pthread_rwlock_t នៅលើប្រព័ន្ធ POSIX ឬ SRWLOCK នៅលើ Windows ឬពួកគេនឹងប្រើបណ្ណាល័យភាគីទីបីដូចជា Boost ជាដើម។ គណៈកម្មាធិការស្តង់ដារ 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 មានតម្លៃជាពិសេស ពីព្រោះតក្កវិជ្ជាស្របគ្នាគឺពិបាករកហេតុផលណាស់។ មតិយោបល់ដែលបានដាក់យ៉ាងល្អបញ្ជាក់មូលហេតុប្រភេទចាក់សោជាក់លាក់មួយត្រូវបានជ្រើសរើស ដែលកាត់បន្ថយយ៉ាងខ្លាំងនូវហានិភ័យរបស់អ្នកថែទាំនាពេលអនាគតដែលណែនាំការប្រណាំងទិន្នន័យដោយចៃដន្យ។ នេះគឺជាគំរូធម្មតា៖

#include 
#រួមបញ្ចូល 
# រួមបញ្ចូល 

ថ្នាក់ ConfigRegistry {
    អាចផ្លាស់ប្តូរបាន std::shared_mutex mtx_; // ការពារផែនទីខាងក្រោម
    std::unordered_map data_;

សាធារណៈ៖
    // អានផ្លូវ៖ ខ្សែស្រឡាយច្រើនអាចហៅវាក្នុងពេលដំណាលគ្នា។
    std::string get(const std::string&key) const {
        std::shared_lock lock(mtx_); // ចាក់សោដែលបានចែករំលែក — មានសុវត្ថិភាពសម្រាប់ការអានក្នុងពេលដំណាលគ្នា។
        auto it = data_.find(key);
        ត្រឡប់វា != data_.end() ? it->វិនាទី : "";
    }

    // ផ្លូវសរសេរ៖ ទាមទារសិទ្ធិចូលប្រើផ្តាច់មុខ
    void set(const std::string&key, const std::string&val) {
        std::unique_lock lock(mtx_); // ចាក់សោផ្តាច់មុខ — រារាំងអ្នកអានទាំងអស់។
        data_[key] = val;
    }
};

សូមកត់សម្គាល់ពីរបៀបដែលមតិយោបល់ពន្យល់ពីចេតនានៅពីក្រោយជម្រើសចាក់សោនីមួយៗ ជាជាងគ្រាន់តែបញ្ជាក់ឡើងវិញនូវអ្វីដែលលេខកូដធ្វើ។ នេះគឺជាស្តង់ដារមាស៖ មតិគួរតែឆ្លើយ ហេតុអ្វី មិនមែន អ្វី។ ពាក្យគន្លឹះ mutable នៅលើ mutex អនុញ្ញាតឱ្យ get() ត្រូវបានប្រកាសថា const ខណៈពេលដែលនៅតែអាចចាក់សោបាន ដែលជាលំនាំធម្មតា និងអនាមិក។

Key Insight៖ តែងតែប្រើ RAII lock wrappers (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() សម្រាប់ការព្យាយាមកំណត់ពេលវេលា។ std::shared_mutex របស់ C++17 ទម្លាក់​វ៉ារ្យ៉ង់​ដែល​កំណត់​ពេល​វេលា​សម្រាប់​ការ​អនុវត្ត​តិច​ជាង​មុន។ ប្រសិនបើអ្នកត្រូវការការចាក់សោតាមពេលវេលានៅលើផ្លូវដែលបានចែករំលែក std::shared_timed_mutex នៅតែមាន ហើយប្រភេទទាំងពីរនេះគឺមានលក្ខណៈស្តង់ដារពេញលេញ។

សម្រាប់ជម្រើសដែលគ្មានការចាក់សោ std::atomic រួមបញ្ចូលគ្នាជាមួយនឹងការបញ្ជាអង្គចងចាំដោយប្រយ័ត្នប្រយែង ជួនកាលអាចជំនួស mutex ទាំងស្រុងសម្រាប់ទង់ ឬបញ្ជរសាមញ្ញ ប៉ុន្តែសម្រាប់រចនាសម្ព័ន្ធទិន្នន័យស្មុគស្មាញ std::shared_mutex នៅតែជាដំណោះស្រាយដែលអាចអានបាន និងរក្សាបានបំផុតនៅក្នុងបណ្ណាល័យស្តង់ដារ។

សំណួរដែលគេសួរញឹកញាប់

អាច std::shared_mutex បណ្តាលឱ្យមានការអត់ឃ្លាន?

បាទ វាអាចទៅរួច។ ប្រសិនបើអ្នកកាន់សោដែលបានចែករំលែកថ្មីបន្តមកដល់ជាបន្តបន្ទាប់ អ្នកស្នើសុំចាក់សោផ្តាច់មុខអាចរង់ចាំដោយគ្មានកំណត់ ដែលជាបញ្ហាការអត់ឃ្លានរបស់អ្នកនិពន្ធ។ ស្តង់ដារ C ++ មិនកំណត់គោលនយោបាយយុត្តិធម៌ជាក់លាក់ទេ ដូច្នេះអាកប្បកិរិយាអាស្រ័យលើការអនុវត្ត។ នៅក្នុងការអនុវត្ត ការអនុវត្តបណ្ណាល័យស្ដង់ដារភាគច្រើនផ្តល់អាទិភាពដល់ការចាក់សោផ្តាច់មុខដែលមិនទាន់សម្រេចនៅពេលដែលពួកគេត្រូវបានតម្រង់ជួរ ប៉ុន្តែអ្នកគួរតែផ្ទៀងផ្ទាត់វាសម្រាប់ខ្សែសង្វាក់ឧបករណ៍ និងវេទិកាជាក់លាក់របស់អ្នក ប្រសិនបើភាពអត់ឃ្លានគឺជាការព្រួយបារម្ភក្នុងផលិតកម្ម។

តើ std::shared_mutex មានសុវត្ថិភាពក្នុងការប្រើជាមួយ std::condition_variable ដែរឬទេ?

std::condition_variable ទាមទារ std::unique_lock ដូច្នេះវាមិនត្រូវគ្នាដោយផ្ទាល់ជាមួយ std::shared_mutex ទេ។ ប្រសិនបើអ្នកត្រូវការរង់ចាំលក្ខខណ្ឌមួយខណៈពេលកំពុងកាន់ mutex ដែលបានចែករំលែក សូមប្រើ std::condition_variable_any ដែលដំណើរការជាមួយប្រភេទ BasicLockable ណាមួយ រួមទាំង std::shared_mutex ដែលផ្គូផ្គងជាមួយ std::shared_lock។

តើខ្ញុំគួរបន្ថែមមតិយោបល់រាល់ពេលដែលខ្ញុំប្រើ std::shared_mutex?

យ៉ាងហោចណាស់ សូមបញ្ចេញមតិលើសេចក្តីប្រកាសនៃ mutex ដើម្បីពិពណ៌នាអំពីទិន្នន័យដែលវាការពារ និងបំរែបំរួលដែលវារក្សា។ នៅលើគេហទំព័រចាក់សោនីមួយៗ មតិយោបល់ខ្លីៗដែលពន្យល់ពីមូលហេតុដែលចែករំលែកធៀបនឹងការចូលប្រើផ្តាច់មុខត្រូវបានជ្រើសរើស បន្ថែមតម្លៃយ៉ាងសំខាន់សម្រាប់អ្នកត្រួតពិនិត្យកូដ និងអ្នកថែទាំនាពេលអនាគត។ កំហុសស្របគ្នាគឺជាបញ្ហាដ៏លំបាកបំផុតក្នុងការផលិតឡើងវិញ និងជួសជុល ដូច្នេះការវិនិយោគលើមតិយោបល់ច្បាស់លាស់ និងច្បាស់លាស់ ផ្តល់ភាគលាភច្រើនដង។

ការគ្រប់គ្រងប្រព័ន្ធស្មុគ្រស្មាញ — មិនថាកូដ C++ ដំណាលគ្នា ឬប្រតិបត្តិការអាជីវកម្មទាំងមូល — ទាមទារឧបករណ៍ត្រឹមត្រូវ និងរចនាសម្ព័ន្ធច្បាស់លាស់។ Mewayz គឺជាប្រព័ន្ធប្រតិបត្តិការអាជីវកម្ម 207-module ដែលត្រូវបានជឿទុកចិត្តដោយអ្នកប្រើប្រាស់ជាង 138,000 នាក់ ដើម្បីនាំមកនូវភាពច្បាស់លាស់ដូចគ្នាទៅនឹងទីផ្សារ CRM, e-commerce, analytics និងច្រើនទៀត ដែលទាំងអស់នៅក្នុងវេទិកាមួយចាប់ផ្តើមត្រឹមតែ $19 ក្នុងមួយខែ។ បញ្ឈប់ការលេងឧបករណ៍ដែលផ្តាច់រាប់សិប ហើយចាប់ផ្តើមដំណើរការអាជីវកម្មរបស់អ្នកជាមួយនឹងភាពជាក់លាក់នៃកម្មវិធីដែលបានរចនាយ៉ាងល្អ។ សាកល្បង Mewayz ថ្ងៃនេះនៅ app.mewayz.com ហើយមើលពីរបៀបដែលប្រព័ន្ធបង្រួបបង្រួមផ្លាស់ប្តូររបៀបដែលក្រុមរបស់អ្នកធ្វើការ។