मल्टीथ्रेडिंग के लिए स्मृति का एक हिस्सा लॉक करना - सी ++, मल्टीथ्रेडिंग, सी ++ 11

मैं कुछ कोड लिखने की कोशिश कर रहा हूं जो थ्रेड बनाता है जो स्मृति के विभिन्न हिस्सों को एक साथ संशोधित कर सकता है। मैंने इसे पढ़ा है mutex आमतौर पर कोड लॉक करने के लिए प्रयोग किया जाता है, लेकिन मुझे यकीन नहीं है कि मैं अपनी स्थिति में इसका उपयोग कर सकता हूं। उदाहरण:

using namespace std;
mutex m;
void func(vector<vector<int> > &a, int b)
{
lock_guard<mutex> lk(m);
for (int i = 0; i < 10E6; i++) { a[b].push_back(1); }
}

int main()
{
vector<thread> threads;
vector<vector<int> > ints(4);
for (int i = 0; i < 10; i++)
{
threads.push_back(thread (func, ref(ints), i % 4));
}
for (int i = 0; i < 10; i++) { threads[i].join(); }
return 0;
}

वर्तमान में, म्यूटेक्स बस कोड को अंदर ताला लगा देता है func, इसलिए (मुझे विश्वास है) प्रत्येक धागे को बस समाप्त होने तक बस इंतजार करना पड़ता है।

मैं प्रोग्राम को 4 वैक्टरों को संपादित करने की कोशिश कर रहा हूं ints एक ही समय में, लेकिन यह महसूस करता है कि इसे तब तक इंतजार करना पड़ेगा जब तक कि कुछ अन्य धागे अगले शुरू करने से पहले उन वैक्टरों में से किसी एक को संपादित नहीं कर लेते।

उत्तर:

जवाब के लिए 3 № 1

मुझे लगता है कि आप निम्नलिखित चाहते हैं: (एक std::mutex द्वारा std::vector<int>)

std::mutex m[4];
void func(std::vector<std::vector<int> > &a, int index)
{
std::lock_guard<std::mutex> lock(m[index]);
for (int i = 0; i < 10E6; i++) {
a[index].push_back(1);
}
}

उत्तर № 2 के लिए 1

क्या आपने ए का उपयोग करने पर विचार किया है सिकंदरा एक म्यूटेक्स के बजाय?

निम्नलिखित प्रश्न आपकी मदद कर सकते हैं:

सेमफोर बनाम म्यूटेक्स

हमें म्यूटेक्स का उपयोग कब करना चाहिए और हमें सैमफोर का उपयोग कब करना चाहिए


जवाब के लिए 0 № 3

प्रयत्न:

void func(vector<vector<int> > &a, int b)
{
for (int i=0; i<10E6; i++) {
lock_guard<mutex> lk(m);
a[b].push_back(1);
}
}

साझा ऑब्जेक्ट तक पहुंचने के दौरान आपको केवल अपने म्यूटेक्स को लॉक करने की आवश्यकता है (a)। जिस तरह से आपने कार्यान्वित किया func इसका मतलब है कि अगले धागे को चलाने से पहले एक थ्रेड पूरे लूप को खत्म करना होगा।


संबंधित सवाल
सबसे लोकप्रिय