ConcurrentHashMap ताले पढ़ने और लिखने

Question

मैं इनका जवाब खोजने का प्रयास कर रहा हूं, लेकिन इसे Google या जावा दस्तावेज़ों में नहीं ढूंढ पा रहा हूं।

केस 1: ConcurrentHashMap में, मान लीजिए एक धागा t1 खंड n से पढ़ रही है, और एक ही एक और धागा t2 पर एक ही खंड n पर लिखना चाहते हैं:

प्रश्न 1: क्या ये दो ऑपरेशन एक के बाद एक होंगे, या वे एक साथ निष्पादित करेंगे?

केस 2:ConcurrentHashMap में, एक धागा t1 खंड n पर लिख रहा है लगता है, और एक ही एक और धागा t2एक ही खंड n से पढ़ना चाहते हैं पर,

प्रश्न 2: क्या ये दो ऑपरेशन एक के बाद एक होंगे, या वे एक साथ निष्पादित करेंगे?

Answer 1

मैं जावाडोक जवाब दोनों अपने प्रश्नों लगता है:

रिट्रीवल (प्राप्त सहित) आम तौर पर ब्लॉक नहीं करती संचालन, तो अद्यतन संचालन के साथ ओवरलैप (रख दिया और हटाने सहित) हो सकता है। पुनर्प्राप्ति सबसे हाल ही में पूरा किए गए अपडेट ऑपरेशंस के परिणाम उनके प्रारंभ पर होल्डिंग के परिणाम दर्शाती है। PutAll और स्पष्ट संचालन के लिए कुल समेकन के लिए, समवर्ती पुनर्प्राप्ति केवल कुछ प्रविष्टियों को सम्मिलित या हटाने को प्रतिबिंबित कर सकती है।

सेगमेंट अद्यतन के संचालन के लिए कर रहे हैं:

अद्यतन आपरेशनों के बीच की अनुमति दी संगामिति वैकल्पिक concurrencyLevel निर्माता तर्क (डिफ़ॉल्ट 16) है, जो आंतरिक आकार के लिए एक संकेत के रूप में इस्तेमाल किया है द्वारा निर्देशित है।

तो, संक्षेप में, पढ़ा नहीं जाता है (इसे अस्थिर चर पढ़ने के रूप में लागू किया जाता है)। यदि वे एक ही सेगमेंट में लिखते हैं तो लेखन एक-दूसरे को अवरुद्ध कर सकते हैं।

सार्वजनिक ConcurrentHashMap (int initialCapacity, नाव loadFactor इंट concurrencyLevel)

तो उपरोक्त पंक्ति एक बनाता है:

Answer 2

ConcurrentHashMap ओरेकल डॉक्स के अनुसार,

ConcurrentHashMap के निर्माता इस तरह दिखता है निर्दिष्ट प्रारंभिक क्षमता, लोड कारक और समवर्ती स्तर के साथ नया, खाली नक्शा। जहां, महत्वपूर्ण ConcurrentHashMap निर्माता से विचार करने के लिए पैरामीटर:

• initialCapacity - आरंभिक क्षमता। कार्यान्वयन इन कई तत्वों को समायोजित करने के लिए आंतरिक आकार का प्रदर्शन करता है।
• concurrencyLevel - समवर्ती रूप से अद्यतन धागे की अनुमानित संख्या। कार्यान्वयन इस कई धागे को समायोजित करने का प्रयास करने के लिए आंतरिक आकार का प्रदर्शन करता है।

ConcurrentHashMap Api में, आपको निम्न स्थिरांक मिलेंगे।

• स्थिर अंतिम int DEFAULT_INITIAL_CAPACITY = 16;
• स्थैतिक अंतिम int DEFAULT_CONCURRENCY_LEVEL = 16;

प्रारंभिक क्षमता पैरामीटर और ConcurrentHashMap कन्स्ट्रक्टर (या ऑब्जेक्ट) के समवर्ती स्तर पैरामीटर डिफ़ॉल्ट रूप से 16 पर सेट हैं।

इस प्रकार, मानचित्र के विस्तृत लॉक के बजाय, ConcurrentHashMap डिफ़ॉल्ट रूप से 16 ताले की एक सूची बनाए रखता है (प्रारंभिक क्षमता के बराबर ताले की संख्या, जो डिफ़ॉल्ट रूप से 16 है) प्रत्येक का उपयोग एक बाल्टी को लॉक करने के लिए किया जाता है नक्शा। यह इंगित करता है कि 16 धागे (समरूपता स्तर के बराबर धागे की संख्या, जो डिफ़ॉल्ट रूप से 16 है) एक ही समय में संग्रह को संशोधित कर सकती है, प्रत्येक थ्रेड अलग-अलग बाल्टी पर काम करता है। तो हैशटेबल के विपरीत, हम ConcurrentHashMap में पूरे मानचित्र पर लॉक किए बिना किसी भी प्रकार का ऑपरेशन (अपडेट, डिलीट, रीड, बिल्ड) करते हैं।

रिट्रीवल परिचालन (प्राप्त सहित) आम तौर पर ब्लॉक नहीं है। यह इस मामले में अस्थिरता की अवधारणा का उपयोग करता है।, इसलिए अद्यतन संचालन (डाल और निकालने सहित) के साथ ओवरलैप हो सकता है। पुनर्प्राप्ति उनके प्रारंभ होने पर हाल ही में किए गए नवीनतम अपडेट ऑपरेशन के परिणामों को दर्शाती है।

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

मुझे आशा है कि इससे मदद मिलती है!