यह वह कोड है जहां मैं एक अनियंत्रित मानचित्र में मान डालूंगा और नियमित अंतराल पर उन मानों को भी पूछूंगा।

class MemoryMap
{
private:
    std::unordered_map<std::string, std::string> maps_;
    std::mutex mutex_;
    


public:
    void AddMap(std::string key, std::string value);
    std::string GetMap(std::string key);
    void PrintMemoryMap(std::string key);

};



void MemoryMap::AddMap(std::string key, std::string value)
{
    std::unique_lock<std::mutex> lock(mutex_);
    maps_[key] = value;
    
}

std::string MemoryMap::GetMap(std::string key)
{
    std::unique_lock<std::mutex> lock(mutex_);
    if (maps_.find(key) == maps_.end())
        return "";
    
        return maps_.at(key);
}

मैं इस ऑब्जेक्ट को दो अलग-अलग थ्रेड्स में उपयोग कर रहा हूं और मैं चाहता हूं कि जब AddMap फ़ंक्शन के माध्यम से सम्मिलन हो रहा हो तो GetMap फ़ंक्शन को सम्मिलन समाप्त होने की प्रतीक्षा करनी चाहिए। इसके अलावा GetMap फ़ंक्शन को समवर्ती रूप से बुलाया जाएगा।

क्या मेरा वर्तमान कोड इस समस्या को हल करने के लिए पर्याप्त है?

1
shomit 13 पद 2020, 09:32
1
GetMap में सुधार किया जा सकता है: auto it = maps_.find(key); return it == maps_.end() ? "" : *it;। (2 के बजाय एक लुक-अप)
 – 
Jarod42
13 पद 2020, 12:26

1 उत्तर

सबसे बढ़िया उत्तर

यह पर्याप्त है। म्यूटेक्स लॉक गारंटी एक ही समय में कॉल प्राप्त या सेट करने के लिए अधिकतम एक थ्रेड प्राप्त करता है।

हालांकि, यदि आप समवर्ती पठन प्राप्त करना चाहते हैं तो आपका कोड अनुकूलित नहीं किया जा सकता है। C++ में, unordered_map एक कंटेनर है, जिसमें थ्रेड सुरक्षा इस प्रकार है: https ://en.cppreference.com/w/cpp/container#Thread_safety दो थ्रेड सुरक्षित रूप से एक ही समय में get को कॉल कर सकते हैं क्योंकि यह एक स्थिर कार्य है, यदि कोई थ्रेड कंटेनर को संशोधित नहीं कर रहा है।

1
Fan Jin 13 पद 2020, 10:00
अगर मैं समवर्ती पढ़ना चाहता हूं तो मुझे अपने कोड में क्या संशोधित करना चाहिए?
 – 
shomit
13 पद 2020, 10:03
2
क्या आपके पास सी ++ 17 है? यदि ऐसा है, तो आप समवर्ती पठन को सक्षम करने के लिए std::shared_mutex का उपयोग कर सकते हैं।
 – 
jignatius
13 पद 2020, 10:13
मेरे पास सी ++ 14 तक है।
 – 
shomit
13 पद 2020, 10:13
उस स्थिति में, आपका कार्यान्वयन ठीक है। आपको म्यूटेक्स को वैसे ही लॉक करने की आवश्यकता है जैसे आप कर रहे हैं क्योंकि आपके पास कम से कम एक फ़ंक्शन है जो मानचित्र को संशोधित करता है। केवल अगर यह केवल-पढ़ने के लिए नक्शा है, तो आपको स्वयं कोई थ्रेड सिंक्रनाइज़ेशन प्रदान करने की आवश्यकता नहीं है।
 – 
jignatius
13 पद 2020, 10:20
1
हाँ, निश्चित रूप से आप करते हैं। आप std::unique_lock के बजाय std::lock_guard का उपयोग कर सकते हैं क्योंकि आप बाद की अतिरिक्त सुविधाओं का उपयोग नहीं कर रहे हैं। std::lock_guard भी कम खर्चीला है।
 – 
jignatius
13 पद 2020, 10:32