कॉनवे के जीवन के खेल के लिए मल्टीथ्रेडेड जावा प्रोग्राम - सीमा कोशिकाओं पर विवाद

Question

मैं जावा में समवर्ती प्रोग्रामिंग सीख रहा हूं, और गेम ऑफ लाइफ के लिए सिमुलेशन लिख रहा हूं।

यहाँ मैं क्या सोच रहा हूँ है:

• उपयोग पूर्णांक [] [] कोशिकाओं के राज्यों की दुकान
• विभाजन पूर्णांक टी खंडों में [] [] और टी कार्यकर्ता धागे का उपयोग करने के
• टी थ्रेड अपने सेगमेंट से पढ़े जाएंगे, अपने सेगमेंट में सभी सेल्स के लिए नए मानों की गणना करेंगे और कोशिकाओं को अपडेट करेंगे।
• एक बार जब वे गणना समाप्त कर लेते हैं तो वे अन्य श्रमिकों के लिए
• समाप्त करने के लिए बाधा को प्रतीक्षा करते हैं जब बाधा पार हो जाता है मुख्य थ्रेड यूआई अपडेट करेगा।
• श्रमिक अगले राज्य की गणना करने के लिए आगे बढ़ते हैं।

अब सेगमेंट की सामान्य सीमाओं पर विवाद होने जा रहा है। यदि कोई पड़ोसी अपने पड़ोसी को पिछले मूल्य को पढ़ने से पहले सीमा कक्ष की स्थिति को ओवरराइट करता है, तो पड़ोसी की गणना गलत होगी।

मेरे विकल्प क्या हैं?

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

मेरे सवाल है, वहाँ सीमा कोशिकाओं पर विवाद है कि कॉपी करने डेटा को शामिल नहीं करता या कि उपरोक्त दो विकल्प और अधिक कुशल है से निपटने के लिए किसी भी अन्य तरीका है? रीडरवाइटर लॉक, अस्थिर चर या अन्य सिंक्रनाइज़िंग तंत्र का उपयोग कर सकते हैं?

अद्यतन: अब तक double buffering solution by Peter सबसे साफ है। लेकिन मेरे पास एक प्रश्न है। चूंकि दो सरणी साझा डेटा हैं और हम किसी सिंक्रनाइज़ेशन (सिंक्रनाइज़ एक्सेस या अस्थिर चर) का उपयोग नहीं कर रहे हैं, क्या यह दृश्यता समस्या नहीं बनाएगा? क्या कई सीपीयू सरणी मानों को कैश कर सकते हैं और प्रत्येक पुनरावृत्ति के साथ सरणी का केवल एक हिस्सा अपडेट कर सकते हैं? फिर थ्रेड को सीमा कोशिकाओं के लिए पुरानी मान मिल जाएगी। क्या यह संभव है? यदि नहीं, क्यों। यदि हां, तो मैं इसे कैसे हल करूं? ऐसा लगता है declaring two arrays volatile will not make their individual elements volatile।

Answer 1

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

कहा जा रहा है कि, मैं थोड़ी पक्षपातपूर्ण हूं क्योंकि मैं एक कार्यात्मक तरीके से प्रोग्राम करना पसंद करता हूं, सिवाय इसके कि जब कोई मजबूत कारण न हो।

Answer 2

मैं निम्नलिखित दृष्टिकोण की कोशिश करेंगे:

• कार्यकर्ताओं परिकलन है, लेकिन केवल भीतरी कोशिकाओं को मान वापस लिखें।
• सीमा कोशिकाओं के लिए, परिणामों को संग्रहित करें।
• जब गणना पूर्ण हो जाती है, तो बाधा पर प्रतीक्षा करें।
• जब सभी कर्मचारी पहले बाधा पर हैं, तब रिलीज़ करें और प्रत्येक को सीमा कक्ष लिखने दें। एक दूसरे बाधा पर
• होने तक प्रतीक्षा यूआई अद्यतन

भंडारण एक n x m टाइल के लिए आवश्यक 2 * (n + m - 1) है, इसलिए आम तौर पर बड़े टाइल (8x8 या अधिक) कैश की गई मूल्यों के लिए आनुपातिक रूप से कम स्मृति की आवश्यकता है।

Answer 3

मेरा सुझाव है कि 2 int [] [] arrays। आइए उन्हें ए और बी को कॉल करें। सभी अजीब संख्या वाले "टिक" के मूल्यों को पकड़ेंगे और बी भी संख्याबद्ध टिकों को पकड़ेंगे।

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

लाभ:

• डेटा की कोई नकल अब तुम क्या की तुलना में। प्रति सेल केवल एक ही लेखन हो रहा है।
• किनारे/कोने के मामलों के बारे में चिंता करने की ज़रूरत नहीं है, क्योंकि एल्गोरिदम सरल है।
• स्मृति की कोई आवंटित आवंटन नहीं। जब आप शुरू करते हैं तो बस दो सरणी आवंटित करें।

नुकसान:

• आप दो बार के रूप में ज्यादा स्मृति को आबंटित करने की जरूरत है।

Answer 4

मैं बस java.util.concurrent.Exchanger<V> पर ठोकर खाई। यह विनिमय के बिंदु के रूप में कार्य करता है। मैं संभवतः आसन्न धागे के बीच सेल-स्टेटस की सूचियों का आदान-प्रदान करने के लिए इसका उपयोग कर सकता हूं। यह बाधा से बेहतर होगा क्योंकि मुझे केवल आसन्न श्रमिकों के बीच सिंक्रनाइज़ करने की आवश्यकता है।

Answer 5

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