ConcurrentHashMap原理分析

KendrickLon 8年前發布 | 7K 次閱讀 Java開發

來自： http://blog.csdn.net//chenleixing/article/details/46906333


??
集合是編程中最常用的數據結構。而談到并發，幾乎總是離不開集合這類高級數據結構的支持。比如兩個線程需要同時訪問一個中間臨界區（Queue），比如常會用緩存作為外部文件的副本（HashMap）。這篇文章主要分析jdk1.5的3種并發集合類型（concurrent，copyonright，queue）中的ConcurrentHashMap，讓我們從原理上細致的了解它們，能夠讓我們在深度項目開發中獲益非淺。
       在tiger之前，我們使用得最多的數據結構之一就是HashMap和Hashtable。大家都知道，HashMap中未進行同步考慮，而Hashtable則使用了synchronized，帶來的直接影響就是可選擇，我們可以在單線程時使用HashMap提高效率，而多線程時用Hashtable來保證安全。
       當我們享受著jdk帶來的便利時同樣承受它帶來的不幸惡果。通過分析Hashtable就知道，synchronized是針對整張Hash表的，即每次鎖住整張表讓線程獨占，安全的背后是巨大的浪費，慧眼獨具的Doug Lee立馬拿出了解決方案----ConcurrentHashMap。
       ConcurrentHashMap和Hashtable主要區別就是圍繞著鎖的粒度以及如何鎖。如圖
 
       左邊便是Hashtable的實現方式---鎖整個hash表；而右邊則是ConcurrentHashMap的實現方式---鎖桶（或段）。ConcurrentHashMap將hash表分為16個桶（默認值），諸如get,put,remove等常用操作只鎖當前需要用到的桶。試想，原來只能一個線程進入，現在卻能同時16個寫線程進入（寫線程才需要鎖定，而讀線程幾乎不受限制，之后會提到），并發性的提升是顯而易見的。
       更令人驚訝的是ConcurrentHashMap的讀取并發，因為在讀取的大多數時候都沒有用到鎖定，所以讀取操作幾乎是完全的并發操作，而寫操作鎖定的粒度又非常細，比起之前又更加快速（這一點在桶更多時表現得更明顯些）。只有在求size等操作時才需要鎖定整個表。而在迭代時，ConcurrentHashMap使用了不同于傳統集合的快速失敗迭代器（見之前的文章《JAVA API備忘---集合》）的另一種迭代方式，我們稱為弱一致迭代器。在這種迭代方式中，當iterator被創建后集合再發生改變就不再是拋出ConcurrentModificationEx ception，取而代之的是在改變時new新的數據從而不影響原有的數據，iterator完成后再將頭指針替換為新的數據，這樣iterator線程可以使用原來老的數據，而寫線程也可以并發的完成改變，更重要的，這保證了多個線程并發執行的連續性和擴展性，是性能提升的關鍵。
       接下來，讓我們看看ConcurrentHashMap中的幾個重要方法，心里知道了實現機制后，使用起來就更加有底氣。
       ConcurrentHashMap中主要實體類就是三個：ConcurrentHashMap（整個Hash表）,Segment（桶），HashEntry（節點），對應上面的圖可以看出之間的關系。
       get方法（請注意，這里分析的方法都是針對桶的，因為ConcurrentHashMap的最大改進就是將粒度細化到了桶上），首先判斷了當前桶的數據個數是否為0，為0自然不可能get到什么，只有返回null，這樣做避免了不必要的搜索，也用最小的代價避免出錯。然后得到頭節點（方法將在下面涉及）之后就是根據hash和key逐個判斷是否是指定的值，如果是并且值非空就說明找到了，直接返回；程序非常簡單，但有一個令人困惑的地方，這句return readValueUnderLock(e)到底是用來干什么的呢？研究它的代碼，在鎖定之后返回一個值。但這里已經有一句V v = e.value得到了節點的值，這句return readValueUnderLock(e)是否多此一舉？事實上，這里完全是為了并發考慮的，這里當v為空時，可能是一個線程正在改變節點，而之前的get操作都未進行鎖定，根據bernstein條件，讀后寫或寫后讀都會引起數據的不一致，所以這里要對這個e重新上鎖再讀一遍，以保證得到的是正確值，這里不得不佩服Doug Lee思維的嚴密性。整個get操作只有很少的情況會鎖定，相對于之前的Hashtable，并發是不可避免的啊！
        V get(Object key, int hash) {
            if (count != 0) { // read-volatile
                HashEntry e = getFirst(hash);
                while (e != null) {
                    if (e.hash == hash && key.equals(e.key)) {
                        V v = e.value;
                        if (v != null)
                            return v;
                        return readValueUnderLock(e); // recheck
                    }
                    e = e.next;
                }
            }
            return null;
        }

 

        V readValueUnderLock(HashEntry e) {
            lock();
            try {
                return e.value;
            } finally {
                unlock();
            }
        }

 

    put操作一上來就鎖定了整個segment，這當然是為了并發的安全，修改數據是不能并發進行的，必須得有個判斷是否超限的語句以確保容量不足時能夠rehash，而比較難懂的是這句int index = hash & (tab.length - 1)，原來segment里面才是真正的hashtable，即每個segment是一個傳統意義上的hashtable,如上圖，從兩者的結構就可以看出區別，這里就是找出需要的entry在table的哪一個位置，之后得到的entry就是這個鏈的第一個節點，如果e!=null，說明找到了，這是就要替換節點的值（onlyIfAbsent == false），否則，我們需要new一個entry，它的后繼是first，而讓tab[index]指向它，什么意思呢？實際上就是將這個新entry插入到鏈頭，剩下的就非常容易理解了。

        V put(K key, int hash, V value, boolean onlyIfAbsent) {
            lock();
            try {
                int c = count;
                if (c++ > threshold) // ensure capacity
                    rehash();
                HashEntry[] tab = table;
                int index = hash & (tab.length - 1);
                HashEntry first = (HashEntry) tab[index];
                HashEntry e = first;
                while (e != null && (e.hash != hash || !key.equals(e.key)))
                    e = e.next;

                V oldValue;
                if (e != null) {
                    oldValue = e.value;
                    if (!onlyIfAbsent)
                        e.value = value;
                }
                else {
                    oldValue = null;
                    ++modCount;
                    tab[index] = new HashEntry(key, hash, first, value);
                    count = c; // write-volatile
                }
                return oldValue;
            } finally {
                unlock();
            }
        }

 

    remove操作非常類似put，但要注意一點區別，中間那個for循環是做什么用的呢？（*號標記）從代碼來看，就是將定位之后的所有entry克隆并拼回前面去，但有必要嗎？每次刪除一個元素就要將那之前的元素克隆一遍？這點其實是由entry的不變性來決定的，仔細觀察entry定義，發現除了value，其他所有屬性都是用final來修飾的，這意味著在第一次設置了next域之后便不能再改變它，取而代之的是將它之前的節點全都克隆一次。至于entry為什么要設置為不變性，這跟不變性的訪問不需要同步從而節省時間有關，關于不變性的更多內容，請參閱之前的文章《線程高級---線程的一些編程技巧》

        V remove(Object key, int hash, Object value) {
            lock();
            try {
                int c = count - 1;
                HashEntry[] tab = table;
                int index = hash & (tab.length - 1);
                HashEntry first = (HashEntry)tab[index];
                HashEntry e = first;
                while (e != null && (e.hash != hash || !key.equals(e.key)))
                    e = e.next;

                V oldValue = null;
                if (e != null) {
                    V v = e.value;
                    if (value == null || value.equals(v)) {
                        oldValue = v;
                        // All entries following removed node can stay
                        // in list, but all preceding ones need to be
                        // cloned.
                        ++modCount;
                        HashEntry newFirst = e.next;
                    *    for (HashEntry p = first; p != e; p = p.next)
                    *        newFirst = new HashEntry(p.key, p.hash, 
                                                          newFirst, p.value);
                        tab[index] = newFirst;
                        count = c; // write-volatile
                    }
                }
                return oldValue;
            } finally {
                unlock();
            }
        }

 

    static final class HashEntry {
        final K key;
        final int hash;
        volatile V value;
        final HashEntry next;

        HashEntry(K key, int hash, HashEntry next, V value) {
            this.key = key;
            this.hash = hash;
            this.next = next;
            this.value = value;
        }
    }

 

    以上，分析了幾個最簡單的操作，限于篇幅，這里不再對rehash或iterator等實現進行討論，有興趣可以參考src。

    接下來實際上還有一個疑問，ConcurrentHashMap跟HashMap相比較性能到底如何。這在Brian Goetz的文章中已經有過評測http://www.ibm.com/developerworks/cn/java/j-jtp07233/。


 本文由用戶 KendrickLon 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。
 轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。
 本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！