सी ++ थ्रेड-सेफ मैप

Question

क्या कोई जानता है कि मुझे एक इम्प्लिमेंटेशन कहां मिल सकता है जो एसटीएल मानचित्र को लपेटता है और इसे थ्रेड सुरक्षित बनाता है? जब मैं थ्रेड सुरक्षित कहता हूं तो मेरा मतलब है कि यह एक समय में केवल एक थ्रेड, मानचित्र पर सीरियल पहुंच प्रदान करता है। सबसे अच्छा, इस मानचित्र को केवल एसटीएल और बूस्ट संरचनाओं का उपयोग करना चाहिए।

Answer 1

साथ विचार को दिखाने के लिए मानदंड है कि आपके द्वारा निर्दिष्ट को पूरा नहीं करता है कुछ कटौती है, लेकिन आप TBB कंटेनरों पर एक नज़र हो सकता था। concurrent_hash_map कहा जाता है जो कई धागे को मानचित्र में समवर्ती रूप से डेटा तक पहुंचने की अनुमति देता है। कुछ विवरण हैं, लेकिन सबकुछ अच्छी तरह से प्रलेखित है और आपको "समवर्ती कंटेनर" का विचार दे सकता है। अपनी आवश्यकताओं पर निर्भर करता है इस पूरी तरह से अनुचित हो सकता है ...

Answer 2

बूस्ट shared_mutex आपके बाधाओं को दिए गए मानक मानचित्र को लपेटने के लिए सर्वश्रेष्ठ एकाधिक पाठक/एकल लेखक दृष्टिकोण प्रदान करेगा। मैं किसी भी "पूर्व-निर्मित" कार्यान्वयन के बारे में नहीं जानता जो कि इन दोनों से शादी करता है क्योंकि कार्य आम तौर पर मामूली होता है।

Answer 3

यह लागू करने के लिए आवेदन पर निर्भर है। एक "धागा-सुरक्षित" नक्शा नक्शा थ्रेड-सुरक्षित में व्यक्तिगत कॉल करेगा, लेकिन कॉल पर कई संचालन को थ्रेड-सुरक्षित बनाया जाना चाहिए। मानचित्र का उपयोग करने वाले एप्लिकेशन को मानचित्र के साथ एक म्यूटेक्स को जोड़ना चाहिए, और उस म्यूटेक्स का उपयोग उस तक पहुंच को समन्वयित करने के लिए करना चाहिए।

जावा में थ्रेड-सुरक्षित कंटेनर बनाने की कोशिश करना जावा में एक गलती थी, और यह सी ++ में एक गलती होगी।

Answer 4

आम तौर पर संग्रह कक्षाओं को थ्रेड-सुरक्षा प्रदान करने के लिए एक अच्छा विचार नहीं है, क्योंकि वे नहीं जानते कि उनका उपयोग कैसे किया जा रहा है। संग्रहों का उपयोग करने वाले उच्च स्तरीय संरचनाओं में आप अपने लॉकिंग मेचैनिज़्म को लागू करके बहुत बेहतर सेवा प्रदान करेंगे।

Answer 5

इस पुस्तकालय

http://www.codeproject.com/KB/threads/lwsync.aspx

यह एक आधुनिक C++ नीति आधारित दृष्टिकोण में कार्यान्वित किया जाता का प्रयास करें।

यहाँ लिंक से 'वेक्टर' मामले

typedef lwsync::critical_resource<std::vector<int> > sync_vector_t; 
sync_vector_t vec; 

// some thread: 
{ 
    // Critical resource can be naturally used with STL containers. 
    sync_vector_t::const_accessor vec_access = vec.const_access(); 
    for(std::vector<int>::const_iterator where = vec_access->begin(); 
     where != vec_access->end(); 
     ++where; 
     ) 
    std::cout << *where << std::endl; 
} 

sync_vector_t::accessor some_vector_action() 
{ 
    sync_vector_t::accessor vec_access = vec.access(); 
    vec_access->push_back(10); 
    return vec_access; 
    // Access is escalated from within a some_vector_action() scope 
    // So that one can make some other action with vector before it becomes 
    // unlocked. 
} 

{ 
    sync_vector_t::accessor vec_access = some_vector_action(); 
    vec_access->push_back(20); 
    // Elements 10 and 20 will be placed in vector sequentially. 
    // Any other action with vector cannot be processed between those two 
    // push_back's. 
} 

Answer 6

आप Thread Safe Template Library

Answer 7

पर लग सकता है मैं के साथ इस (जो मुझे यकीन है कि दो से अधिक तर्क लेने के लिए सुधार किया जा सकता) आया:

template<class T1, class T2> 
class combine : public T1, public T2 
{ 
public: 

    /// We always need a virtual destructor. 
    virtual ~combine() { } 
}; 

यह तुम क्या करने की अनुमति देता है:

// Combine an std::mutex and std::map<std::string, std::string> into 
// a single instance. 
SCA::combine<std::mutex, std::map<std::string, std::string>> lockableMap; 

// Lock the map within scope to modify the map in a thread-safe way. 
{ 
    // Lock the map. 
    std::lock_guard<std::mutex> locked(lockableMap); 

    // Modify the map. 
    lockableMap["Person 1"] = "Jack"; 
    lockableMap["Person 2"] = "Jill"; 
} 

आप एक std :: recursive_mutex और एक std :: सेट का उपयोग करना चाहते हैं, वह भी काम करेगा।