विभिन्न धागे के लिए डेटा संरचनाएं पास करना

Question

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

यहाँ थ्रेडेड आवेदन की संरचना (भोंडापन के लिए खेद है) है:

    MainThread 
       /  \ 
       /   \ 
       /   \ 
     Thread A    Thread B 
    /  \   /  \ 
    /  \   /  \ 
    /   \  /   \ 
Thread A_1  Thread A_2 Thread B_1 Thread B_2 

प्रत्येक के तहत धागा (जो कई हो सकता है) लिखित, वहाँ केवल दो धागे हो जाएगा और वे क्रमिक रूप से की निकाल दिया जाता है। मेरे पास जो मुद्दा है, मैं पूरी तरह से सुनिश्चित नहीं हूं कि इन धागे में डेटास्ट्रक्चर में कैसे पास किया जाए।

तो, डेटास्ट्रक्चर मेन थ्रेड में बनाया गया है, उस थ्रेड के लिए निर्दिष्ट लेटर्ड थ्रेड (थ्रेड ए, आदि) में संशोधित किया जाएगा और फिर उस डेटास्ट्रक्चर से सदस्य चर को Letter_Numbered थ्रेड पर भेजा जाएगा।

वर्तमान में, लिखित धागा वर्ग एक सदस्य चर है और जब वर्ग का निर्माण किया है, mainthread से आंकड़ा संरचना संदर्भ द्वारा में पारित हो जाता है, प्रतिलिपि निर्माता लागू तो लिखित धागा इसके साथ खेलने के लिए स्वयं की प्रतिलिपि है है।

लेटरर्ड क्रमांकित धागा बस लेटर्ड थ्रेड के भीतर डेटा संरचना से एक स्ट्रिंग चर में ले जाता है। मेरा सवाल है, क्या यह स्वीकार्य है? क्या यह सुनिश्चित करने का एक बेहतर तरीका है कि प्रत्येक लेटर्ड थ्रेड के साथ खेलने के लिए अपनी डेटा संरचना हो जाए?

कुछ हद तक खराब स्पष्टीकरण के लिए खेद है, कृपया टिप्पणियां छोड़ें और मैं स्पष्ट करने की कोशिश करूंगा।

संपादित करें: तो मेरे लेटर्ड थ्रेड कन्स्ट्रक्टर को डेटा संरचना का VALUE लेना चाहिए, संदर्भ नहीं?

Answer 1

मैं प्रत्येक थ्रेड को डेटास्ट्रक्चर की अपनी प्रति बनाउंगा, उदाहरण के लिए आप कन्स्ट्रक्टर में संरचना पास करते हैं और फिर स्पष्ट रूप से स्थानीय प्रतिलिपि बनाते हैं। फिर आप गारंटी देते हैं कि धागे की अलग प्रतियां होती हैं। (आप कहते हैं कि यह संदर्भ द्वारा पारित किया गया है, और यह कॉपी कन्स्ट्रक्टर को आमंत्रित करता है। मुझे लगता है कि आपका मतलब मूल्य से गुजरता है? मुझे लगता है कि स्पष्ट रूप से एक प्रतिलिपि बनाना, संदेह छोड़ना और अपना इरादा स्पष्ट करना बेहतर है। अन्यथा कोई बाद में "स्मार्ट ऑप्टिमाइज़ेशन" के रूप में संदर्भ द्वारा पास करने के लिए मूल्य के साथ आते हैं और अपना पास बदलते हैं।)

संपादित करें: तारों के बारे में टिप्पणी हटा दी गई है। किसी कारण से, मैं .NET मान रहा था।

सुनिश्चित करने के लिए तार निजी स्वामित्व वाली हैं, एक ही प्रक्रिया का पालन करें, स्ट्रिंग, जिसे फिर आप स्वतंत्र रूप से संशोधित कर सकते हैं की एक प्रतिलिपि बनाने।

Answer 2

क्या आपने boost threads पर देखा है?

आप मूल रूप से एक कॉल करने योग्य वर्ग बनाते हैं जिसमें एक कन्स्ट्रक्टर होता है जो थ्रेड को काम करने के लिए पैरामीटर लेता है और फिर अपने कॉल करने योग्य वर्ग की वस्तुओं को पास करके थ्रेड लॉन्च करता है, आरंभ किया जाता है और जाने के लिए तैयार होता है।

यह बहुत कैसे जावा धागे को लागू करता है के समान है और यह समय की सबसे अधिक उपयुक्त देखने के एक डिजाइन बिंदु से की अच्छी मात्रा में आता है।

Answer 3

एक पैटर्न जिसमें प्रत्येक वस्तु का अपना सूत्र में कार्यान्वित Active Object Pattern कहा जाता है। ACE जैसे फ्रेमवर्क इस का समर्थन करते हैं। यदि आपके पास ऐसे ढांचे तक पहुंच है, तो आपको उन का उपयोग करना चाहिए।किसी भी मामले में, मुझे लगता है कि किसी ऑब्जेक्ट का एक नया उदाहरण बनाने और इसे अपने थ्रेड में एक्स्ट्यूट करने की इजाजत देना बहुत साफ है जो ऑब्जेक्ट की एक प्रति बनाने के लिए कॉपी-कन्स्ट्रक्टर का आह्वान करता है। अन्यथा देखें कि क्या आप ऐसे समाधान को फिट कर सकते हैं जो Thread Local Storage का उपयोग करता है।

Answer 4

आप स्पष्ट रूप से प्रत्येक trhead के लिए डेटा की एक प्रति बना रहे हैं और सबकुछ काम करता है? तो कोई समस्या नहीं है।

• डेटा केवल पढ़ने के लिए है, तो आप एक भी struct साझा कर सकते हैं और सब कुछ ठीक हो जाएगा, जब तक प्रत्येक पढ़ा है के रूप में छोटे और तेजी से (बुनियादी प्रकार)
• :

  यहाँ कुछ अतिरिक्त विचार कर रहे हैं यदि डेटा को लिखा जाना चाहिए, लेकिन प्रत्येक थ्रेड में "निजी" (या निहित) है, तो प्रत्येक थ्रेड पर एक प्रति भेजें (आप क्या कर रहे हैं)। चेतावनी: मुझे लगता है कि डेटा बहुत बड़ा नहीं है और एक प्रति अधिक संसाधनों को नहीं खाती है।

• यदि डेटा को लिखा जाना चाहिए और नए मान धागे के बीच साझा किए गए हैं, तो आपको इसके बारे में सोचने की आवश्यकता है (इसे पढ़ें) और उचित डिज़ाइन बनाएं। मुझे प्रत्येक धागे को पढ़ने/लिखने के संचालन को केंद्रीकृत करने के लिए एक लेनदेन वस्तु पसंद है। स्मृति में एक छोटे डेटाबेस की तरह। थ्रेड म्यूटेक्स, सेमफोर और महत्वपूर्ण खंडों पर जांचें)। विशाल डेटा सेट से निपटने के लिए मैंने अनुरोधों को केंद्रीकृत करने के लिए डेटाबेस का उपयोग किया है (ओडीबीएम देखें)। डेटा परिवर्तन आदेश और सिंक्रनाइज़ करने के लिए आप मौजूदा संदेश क्व्यूइंग लाइब्रेरी (जैसे एमएसएमक्यू) की जांच भी कर सकते हैं।

आशा इस मदद करता है।

Answer 5

ऐसा लगता है कि आप प्रत्येक थ्रेड को डेटा पर काम करना चाहते हैं और फिर कम से कम कभी-कभी किसी अन्य थ्रेड पर प्रतिक्रिया नहीं होती है कि डेटा पर किसी अन्य धागे के काम के लिए क्या किया गया है। यदि आप वास्तव में स्वतंत्र हैं कि कोई अन्य धागा वास्तव में किसी अन्य धागे के काम के बारे में परवाह नहीं करेगा, तो मैं डेटा की एक प्रति बनाने का सुझाव देता हूं, अन्यथा इस मामले में जहां आप एक थ्रेड में काम करना चाहते हैं और परिणाम उस काम के दूसरे धागे के लिए उपलब्ध है, मैं सुझाव दूंगा कि आप ऑब्जेक्ट के लिए एक संदर्भ/पॉइंटर पास करें और फिर ताले के माध्यम से इसका उपयोग सुरक्षित रखें ताकि धागे इसके साथ काम कर सकें, ठीक है, मैं एक बहु-पढ़ा, एकल लेखक का सुझाव देता हूं लॉक कार्यान्वयन।