समसामयिक हैश मानचित्र जावा के आंतरिक तंत्र-जावा, multithreading, concurrenthashmap

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

सही उत्तर की प्रतीक्षा कर रहा है।

उत्तर:

उत्तर № 1 के लिए 1

नहीं, जावा नक्शा की एक प्रति और न ही सेगमेंट बना देता है, और लिखने के बाद मानचित्र में प्रतिलिपि नहीं करता है।
put तथा get विधियों ने सेगमेंट पर लॉक लगाया है, इसलिए दो धागे के पास एक ही समय में एक ही सेगमेंट तक पहुंच नहीं है।

कृपया कार्यान्वयन पर एक नज़र डालें put तथा get:
http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/concurrent/ConcurrentHashMap.java#ConcurrentHashMap.put%28java.lang.Object%2Cjava। lang.Object% 29

907     public V put(K key, V value) {
908         if (value == null)
909             throw new NullPointerException();
910         int hash = hash(key.hashCode());
911         return segmentFor(hash).put(key, hash, value, false);
912     }

795     public V  get(Object key) {
796         int hash = hash(key.hashCode());
797         return segmentFor(hash).get(key, hash);
798     }

दोनों विधियां एक कुंजी के हैश की गणना करती हैं, फिर कॉल करें segmentFor(hash) जो किसी दिए गए हैश के लिए एक सेगमेंट देता है, और फिर कॉल करता है put तथा get इस सेगमेंट पर तरीके।


सेगमेंट की घोषणा यहां है, यह पुनर्विक्रेता लॉक के वंशज है:
http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/concurrent/ConcurrentHashMap.java#ConcurrentHashMap.Segment

 static final class Segment<K,V> extends ReentrantLock implements Serializable {

और एक कार्यान्वयन get आंग put खंड के भीतर:

351         V  readValueUnderLock(HashEntry<K,V> e) {
352             lock();
353             try {
354                 return e.value;
355             } finally {
356                 unlock();
357             }
358         }
359
360         /* Specialized implementations of map methods */
361
362         V  get(Object key, int hash) {
363             if (count != 0) { // read-volatile
364                 HashEntry<K,V> e = getFirst(hash);
365                 while (e != null) {
366                     if (e.hash == hash && key.equals(e.key)) {
367                         V v = e.value;
368                         if (v != null)
369                             return v;
370                         return readValueUnderLock(e); // recheck
371                     }
372                     e = e.next;
373                 }
374             }
375             return null;
376         }

444         V put(K key, int hash, V value, boolean onlyIfAbsent) {
445             lock();
446             try {
447                 int c = count;
448                 if (c++ > threshold) // ensure capacity
449                     rehash();
450                 HashEntry<K,V>[] tab = table;
451                 int index = hash & (tab.length - 1);
452                 HashEntry<K,V> first = tab[index];
453                 HashEntry<K,V> e = first;
454                 while (e != null && (e.hash != hash || !key.equals(e.key)))
455                     e = e.next;
456
457                 V oldValue;
458                 if (e != null) {
459                     oldValue = e.value;
460                     if (!onlyIfAbsent)
461                         e.value = value;
462                 }
463                 else {
464                     oldValue = null;
465                     ++modCount;
466                     tab[index] = new HashEntry<K,V>(key, hash, first, value);
467                     count = c; // write-volatile
468                 }
469                 return oldValue;
470             } finally {
471                 unlock();
472             }
473         }

ये विधियां बस कॉल करें lock() तथा unlock() जब वे अपना काम कर रहे हों तो सेगमेंट तक पहुंचने के लिए / अन्य धागे को रोकने / अनुमति देने के लिए।


संबंधित सवाल
सबसे लोकप्रिय