🅾️ 👨‍👨‍👧‍👧 🙇 # नोट। ConcurrentHashMap में सावधानी से परमाणु संचालन 👌🏾 🧛🏿 📓

पुराने समय से, जावा में एक अद्भुत मैप इंटरफ़ेस और इसके कार्यान्वयन, विशेष रूप से, हैशपॉप है । और जावा 5 से शुरू होकर, समवर्ती हाशपा भी है। इन दो कार्यान्वयन, उनके विकास और क्या इस विकास को असंगत डेवलपर्स के लिए नेतृत्व कर सकते हैं पर विचार करें।

चेतावनी: यह आलेख OpenJDK 8 स्रोत कोड के उद्धरणों का उपयोग करता है, जिसे GNU जनरल पब्लिक लाइसेंस संस्करण 2 के तहत वितरित किया गया है।

टाइम्स 8 से पहले

जिन लोगों ने लंबे, लंबे समय तक प्रतीक्षा समय पहले जावा 7, और फिर जावा 8 (अब की तरह नहीं, हर छह महीने में एक नया संस्करण) पाया, याद रखें कि मैप के साथ कौन से ऑपरेशन सबसे लोकप्रिय थे। यह है:

यदि आपको संग्रह में एक मान रखने की आवश्यकता है, तो हम पहली विधि का उपयोग करते हैं, और मौजूदा मूल्य प्राप्त करने के लिए, दूसरे का उपयोग करते हैं।

लेकिन क्या होगा यदि आलसी आरंभीकरण की आवश्यकता है? फिर इस तरह का एक कोड दिखाई दिया:

String getOrPut(String key) { String result = map.get(key); //(1) if (result == null) { //(2) result = createValue(key); //(3) map.put(key, result); //(4) } return result; }

हमें कुंजी द्वारा मूल्य मिलता है
वांछित मान पाए जाने पर जाँच करें
यदि कोई मूल्य नहीं मिला है, तो इसे बनाएं
कुंजी द्वारा संग्रह में मूल्य जोड़ें

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

जावा 8 से पहले, बस कोई सुंदर विकल्प नहीं थे। यदि आपको कई मूल्य सृजन को चकमा देने की आवश्यकता है, तो आपको अतिरिक्त ताले का उपयोग करना होगा।
जावा 8 ने चीजों को आसान बना दिया। यह प्रतीत होता है ...

जावा 8 हमारे पास आता है ...

सबसे अनुमानित सुविधा क्या है जो जावा 8 के साथ हमारे पास आई है? यह सही है, लंबोदर। और न केवल लामा, बल्कि मानक पुस्तकालय के सभी प्रकार के एपीआई में उनका समर्थन। मानचित्र डेटा संरचनाओं को अनदेखा नहीं किया गया है। विशेष रूप से, इस तरह के तरीके दिखाई दिए:

इन विधियों के कारण, पहले दिए गए कोड को फिर से लिखना संभव है, बहुत सरल है:

 String getOrPut(String key) { return map.computeIfAbsent(key, this::createValue); }

यह स्पष्ट है कि कोई भी अपने कोड को सरल बनाने का अवसर नहीं देगा। इसके अलावा, समवर्ती HashMap के मामले में, computeIfAbsent विधि भी परमाणु रूप से निष्पादित होती है। यानी createValue को केवल एक बार और केवल तभी बुलाया जाएगा जब वांछित मान अनुपस्थित हो।

आईडीई भी पास नहीं हुआ। इसलिए इंटेलीज आईडीईए नए संस्करण के साथ पुराने संस्करण के ऑटो-प्रतिस्थापन की पेशकश करता है:

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

अचानक!

जब तक अगली लोड टेस्टिंग का समय नहीं आ जाता। और फिर एक भयानक बात सामने आई:

जावा के निम्नलिखित संस्करण पर काम किया:

 Openjdk संस्करण "1.8.0_222"
 OpenJDK रनटाइम एनवायरनमेंट (बिल्ड 1.8.0_222-8u222-b10-1ubuntu1 ~ 18.04.1-b10)
 OpenJDK 64-बिट सर्वर VM (बिल्ड 25.222-b10, मिश्रित मोड)

उन लोगों के लिए जो YourKit जैसे अद्भुत उपकरण से परिचित नहीं हैं।

स्क्रीनशॉट में, क्षैतिज विस्तृत लाइनें समय में एप्लिकेशन थ्रेड्स के संचालन को दिखाती हैं। समय पर एक विशेष क्षण में धारा की स्थिति के आधार पर, पट्टी को इसी रंग में चित्रित किया जाता है:

पीला - धारा बेकार है, काम की प्रतीक्षा कर रहा है;
हरा - धागा चल रहा है, प्रोग्राम कोड निष्पादित कर रहा है;
लाल - यह धागा दूसरे धागे से अवरुद्ध होता है।

यही है, यह पता चला है कि लगभग सभी थ्रेड्स (और वास्तव में स्क्रीनशॉट में दिखाए गए से बहुत अधिक थे) अवरुद्ध स्थिति में लगभग हर समय हैं। और सभी के लिए, ताला एक ही कम्प्यूटरीयर में है समवर्ती HashMap का! और यह इस तथ्य के बावजूद कि इस विशेष लोड परीक्षण की बारीकियों के कारण, इस संग्रह में 6-8 से अधिक मूल्यों को संग्रहीत नहीं किया जा सकता है। यानी किसी दिए गए स्थान में लगभग सभी ऑपरेशन विशेष रूप से मौजूदा मूल्यों का एक रीडिंग हैं।

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

वास्तव में, सब कुछ काफी नहीं है। यदि आप इस विधि के स्रोत कोड को देखते हैं, तो यह पता चलता है कि इसमें दो बहुत मोटे सिंक्रनाइज़ ब्लॉक हैं:

समवर्ती HashMap.computeIfAbsent का कार्यान्वयन

 public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) { if (key == null || mappingFunction == null) throw new NullPointerException(); int h = spread(key.hashCode()); V val = null; int binCount = 0; for (Node<K,V>[] tab = table;;) { Node<K,V> f; int n, i, fh; if (tab == null || (n = tab.length) == 0) tab = initTable(); else if ((f = tabAt(tab, i = (n - 1) & h)) == null) { Node<K,V> r = new ReservationNode<K,V>(); synchronized (r) { if (casTabAt(tab, i, null, r)) { binCount = 1; Node<K,V> node = null; try { if ((val = mappingFunction.apply(key)) != null) node = new Node<K,V>(h, key, val, null); } finally { setTabAt(tab, i, node); } } } if (binCount != 0) break; } else if ((fh = f.hash) == MOVED) tab = helpTransfer(tab, f); else { boolean added = false; synchronized (f) { if (tabAt(tab, i) == f) { if (fh >= 0) { binCount = 1; for (Node<K,V> e = f;; ++binCount) { K ek; V ev; if (e.hash == h && ((ek = e.key) == key || (ek != null && key.equals(ek)))) { val = e.val; break; } Node<K,V> pred = e; if ((e = e.next) == null) { if ((val = mappingFunction.apply(key)) != null) { added = true; pred.next = new Node<K,V>(h, key, val, null); } break; } } } else if (f instanceof TreeBin) { binCount = 2; TreeBin<K,V> t = (TreeBin<K,V>)f; TreeNode<K,V> r, p; if ((r = t.root) != null && (p = r.findTreeNode(h, key, null)) != null) val = p.val; else if ((val = mappingFunction.apply(key)) != null) { added = true; t.putTreeVal(h, key, val); } } } } if (binCount != 0) { if (binCount >= TREEIFY_THRESHOLD) treeifyBin(tab, i); if (!added) return val; break; } } } if (val != null) addCount(1L, binCount); return val; }

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

समवर्ती HashMap.get का कार्यान्वयन

 public V get(Object key) { Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek; int h = spread(key.hashCode()); if ((tab = table) != null && (n = tab.length) > 0 && (e = tabAt(tab, (n - 1) & h)) != null) { if ((eh = e.hash) == h) { if ((ek = e.key) == key || (ek != null && key.equals(ek))) return e.val; } else if (eh < 0) return (p = e.find(h, key)) != null ? p.val : null; while ((e = e.next) != null) { if (e.hash == h && ((ek = e.key) == key || (ek != null && key.equals(ek)))) return e.val; } } return null; }

तो क्या करें? वास्तव में, केवल दो विकल्प हैं: या तो मूल कोड पर लौटें, या इसका उपयोग करें, लेकिन थोड़ा संशोधित संस्करण में:

 String getOrPut(String key) { String result = map.get(key); return (result != null) ? result : map.computeIfAbsent(key, this::createValue); }

निष्कर्ष

सामान्य तौर पर, प्रतीत होता है कि इस तरह के घातक परिणाम से रिफ्लेक्टिंग बहुत अप्रत्याशित हो गया। स्थिति को केवल एक तनाव परीक्षण की उपस्थिति से बचाया गया था, जिसने सफलतापूर्वक गिरावट का खुलासा किया था।

सौभाग्य से, जावा के नए संस्करणों ने इस समस्या को ठीक किया: JDK-8161372 ।

इसलिए सावधान रहें, लुभावने सुझावों पर भरोसा न करें और परीक्षण लिखें। विशेष रूप से तनावपूर्ण।

सभी को जावा!

UPD1: कोल्डविंड द्वारा सही ढंग से नोट किए जाने पर , समस्या ज्ञात हो जाती है: JDK-8161372 । और, ऐसा लगता है, यह जावा 9 के लिए तय किया गया था। लेकिन जावा 8, जावा 11 और यहां तक कि जावा 13 में लेख के प्रकाशन के समय, यह विधि अपरिवर्तित रही।

UPD2: vkovalchuk ने मुझे लापरवाही करते हुए पकड़ लिया। वास्तव में, जावा 9 और नए के लिए, समस्या को अवरुद्ध किए बिना परिणाम की वापसी के साथ एक और शर्त जोड़कर तय किया गया है:

  else if (fh == h // check first node without acquiring lock && ((fk = f.key) == key || (fk != null && key.equals(fk))) && (fv = f.val) != null) return fv;

प्रारंभ में, मैं जावा के अगले संस्करण में एक स्थिति में भाग गया:

 Openjdk संस्करण "1.8.0_222"
 OpenJDK रनटाइम एनवायरनमेंट (बिल्ड 1.8.0_222-8u222-b10-1ubuntu1 ~ 18.04.1-b10)
 OpenJDK 64-बिट सर्वर VM (बिल्ड 25.222-b10, मिश्रित मोड)

और जब मैंने बाद के संस्करणों के स्रोतों को देखा, तो मैंने ईमानदारी से इन पंक्तियों को याद किया, जिससे मैं भटक गया।

इसलिए न्याय के लिए मैंने लेख का मुख्य पाठ सही किया।

# नोट। ConcurrentHashMap में सावधानी से परमाणु संचालन

टाइम्स 8 से पहले

जावा 8 हमारे पास आता है ...

अचानक!

निष्कर्ष

More articles: