कहो, मैं एक डेटा वस्तु है:थ्रेड पूल, शेयर्ड डेटा, जावा तुल्यकालन
class ValueRef { double value; }
कहाँ प्रत्येक डेटा ऑब्जेक्ट एक मास्टर संग्रह में संग्रहीत है:
Collection<ValueRef> masterList = ...;
मैं भी नौकरियों का संग्रह है, जहां प्रत्येक नौकरी में डेटा ऑब्जेक्ट्स का स्थानीय संग्रह होता है (जहां प्रत्येक डेटा ऑब्जेक्ट masterList में भी दिखाई देता है):
class Job implements Runnable {
Collection<ValueRef> neededValues = ...;
void run() {
double sum = 0;
for (ValueRef x: neededValues) sum += x;
System.out.println(sum);
}
}
उपयोग-केस:
for (ValueRef x: masterList) { x.value = Math.random(); }कुछ नौकरियों में नौकरी कतार आबाद।
जागो एक धागा पूल
प्रतीक्षा जब तक हर काम का मूल्यांकन किया गया है
नोट: काम मूल्यांकन के दौरान, सभी मान सभी निरंतर कर रहे हैं। हालांकि धागे ने अतीत में नौकरियों का मूल्यांकन किया है, और कैश किए गए मूल्यों को बनाए रखा है।
प्रश्न: प्रत्येक थ्रेड को नवीनतम मानों को सुनिश्चित करने के लिए आवश्यक न्यूनतम सिंक्रनाइज़ेशन क्या है?
मैं मॉनिटर/लॉक-परिप्रेक्ष्य से सिंक्रनाइज़ समझता हूं, मुझे कैश/फ्लश-परिप्रेक्ष्य से सिंक्रनाइज़ नहीं होता है (यानी सिंक्रनाइज़ किए गए ब्लॉक के प्रवेश/निकास पर स्मृति मॉडल द्वारा क्या गारंटी दी जा रही है)।
मेरे लिए, ऐसा लगता है कि मुझे थ्रेड में एक बार सिंक्रनाइज़ करने की आवश्यकता होनी चाहिए जो मानों को मुख्य स्मृति में नए मानों को करने के लिए अद्यतन करता है, और एक बार प्रति कार्यकर्ता धागा, कैश को फ्लश करने के लिए, ताकि नए मान पढ़े जा सकें। लेकिन मुझे यकीन नहीं है कि यह कैसे करना है।
मेरे दृष्टिकोण: एक वैश्विक मॉनिटर बनाने के लिए: मास्टर सूची अपडेट करते समय,, तो फिर static Object guard = new Object();guard पर सिंक्रनाइज़ करें। फिर आखिरकार, पूल में प्रत्येक थ्रेड के लिए थ्रेड पूल शुरू करने से पहले, खाली ब्लॉक में guard पर सिंक्रनाइज़ करें।
क्या यह वास्तव में उस धागे द्वारा पढ़े गए किसी भी मूल्य की पूरी फ्लश का कारण बनता है? या बस सिंक्रनाइज़ ब्लॉक के अंदर छुआ मूल्य? एक मामले में, एक खाली ब्लॉक के बजाय, शायद मुझे एक बार लूप में प्रत्येक मान को पढ़ना चाहिए?
आपके समय के लिए धन्यवाद।
संपादित करें: मुझे लगता है कि मेरे सवाल करने पर निर्भर करता है, एक बार मैं एक तुल्यकालन ब्लॉक बाहर निकलते हैं, प्रत्येक पहले पढ़ने (उस समय के बाद) मुख्य स्मृति में जाता है? भले ही मैं किस पर सिंक्रनाइज़ किया गया हो?
अस्थिर कीवर्ड – ControlAltDel
का लाभ लेने के लिए लगभग एक आदर्श स्थान की तरह लगता है मैं एक बार (प्रभावी रूप से स्थिर) लिख रहा हूं, लेकिन संभावित रूप से लाखों बार पढ़ रहा हूं। अस्थिरता कभी स्थानीय रूप से कैश नहीं किया जाता है। अगर मैंने हर बार थ्रेड पूल बनाया है, तो कोड ठीक w/o सिंक्रनाइज़ेशन/अस्थिर काम करेगा (क्योंकि कोई पूर्व कैश मौजूद नहीं होगा)। –
मुझे यहां अस्थिरता की आवश्यकता नहीं दिख रही है। यदि ValueRef प्रभावी रूप से अपरिवर्तनीय है, तो इसे वास्तव में अपरिवर्तनीय बनाएं। डबल का प्रयोग करें। निर्धारित होने से पहले प्रत्येक नौकरी के लिए एक नया संग्रह बनाएं और अनमोडिफाइड चयन (केवल एक अनुस्मारक के रूप में) में लपेटें। आप किस समस्या का सामना करते हैं? –