ConcurrentHashMap源碼理解（1.7）

請先閱讀：
HashMap源碼分析
Hashtable類註釋翻譯、源碼分析

一、前言

先來複習下HashMap、HashTable。
HashMap是基於哈希表實現的。每一個元素是一個key-value對，其內部通過單鏈表解決衝突問題，容量不足（超過了閥值）時，同樣會自動增長。
數據結構可表示如下：

HashTable是HashMap是線程安全版，但是使用synchronized來保證線程安全，當線程競爭激烈的情況下的效率非常低下，當一個線程訪問HashTable的同步方法時，其他線程訪問HashTable的同步方法時，可能會進入阻塞或輪詢狀態。究其原因，就是因爲所有訪問HashTable的線程都必須競爭同一把鎖。
數據結構可表示如下：

然後，更高效的ConcurrentHashMap就出現了。ConcurrentHashMap的思路是每一把鎖用於鎖容器其中一部分數據，那麼當多線程訪問容器裏不同數據段的數據時，線程間就不會存在鎖競爭，從而可以有效的提高併發訪問效率。
數據結構圖可表示如下：

二、源碼分析

1、ConcurrentHashMap的結構

ConcurrentHashMap是由Segment數組結構和HashEntry數組結構組成。Segment是一種可重入鎖ReentrantLock，在ConcurrentHashMap裏扮演鎖的角色，HashEntry則用於存儲鍵值對數據。一個ConcurrentHashMap裏包含一個Segment數組，Segment的結構和HashMap類似，是一種數組和鏈表結構， 一個Segment裏包含一個HashEntry數組，每個HashEntry是一個鏈表結構的元素， 每個Segment守護者一個HashEntry數組裏的元素,當對HashEntry數組的數據進行修改時，必須首先獲得它對應的Segment鎖。
類圖可表示如下：

2、構造函數

通過構造函數可以看出：
-ssize表示Segment數組長度
-cap 表示Segment中HashEntry數組的長度
-cap * loadFactor：hashEntry數組填充率，用於HashEntry數組的擴容
-segmentShift、segmentMask：主要作用是用來定位Segment

然後創建segments數組並初始化第一個Segment，其餘的Segment延遲初始化。（這其中的一些細節沒有細究）

@SuppressWarnings("unchecked")
    public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();
        if (concurrencyLevel > MAX_SEGMENTS)
            concurrencyLevel = MAX_SEGMENTS;
        // Find power-of-two sizes best matching arguments
        int sshift = 0;
        int ssize = 1;
        while (ssize < concurrencyLevel) {
            ++sshift;
            ssize <<= 1;
        }
        this.segmentShift = 32 - sshift;
        this.segmentMask = ssize - 1;
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        int c = initialCapacity / ssize;
        if (c * ssize < initialCapacity)
            ++c;
        int cap = MIN_SEGMENT_TABLE_CAPACITY;
        while (cap < c)
            cap <<= 1;
        // create segments and segments[0]
        Segment<K,V> s0 =
            new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                             (HashEntry<K,V>[])new HashEntry[cap]);
        Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
        UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
        this.segments = ss;
    }

3、put()方法

put方法的過程先不看代碼，自己思考下，應該是這個順序吧：

① 計算hash值
② 計算Segment數組對應位置
③ 獲取分段鎖
④ 計算hashEntry數組對應位置
⑤ 判斷hashEntry數組是否需要擴容
⑥ 插入 hashEntry數組 或者鏈表
⑦ 釋放分段鎖

下面具體看下代碼：

public V put(K key, V value) {
        Segment<K,V> s;
        if (value == null)
            throw new NullPointerException();
        int hash = hash(key);
        int j = (hash >>> segmentShift) & segmentMask;
        if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
            s = ensureSegment(j);
        return s.put(key, hash, value, false);
    }

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
            HashEntry<K,V> node = tryLock() ? null :
                scanAndLockForPut(key, hash, value);
            V oldValue;
            try {
                HashEntry<K,V>[] tab = table;
                int index = (tab.length - 1) & hash;
                HashEntry<K,V> first = entryAt(tab, index);
                for (HashEntry<K,V> e = first;;) {
                    if (e != null) {
                        K k;
                        if ((k = e.key) == key ||
                            (e.hash == hash && key.equals(k))) {
                            oldValue = e.value;
                            if (!onlyIfAbsent) {
                                e.value = value;
                                ++modCount;
                            }
                            break;
                        }
                        e = e.next;
                    }
                    else {
                        if (node != null)
                            node.setNext(first);
                        else
                            node = new HashEntry<K,V>(hash, key, value, first);
                        int c = count + 1;
                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                            rehash(node);
                        else
                            setEntryAt(tab, index, node);
                        ++modCount;
                        count = c;
                        oldValue = null;
                        break;
                    }
                }
            } finally {
                unlock();
            }
            return oldValue;
        }

put方法的流程和預想的基本吻合。在獲取到Segment數組對應位置後，調用Segment的put方法。Segment的put方法與HashMap類似。

先嚐試獲取鎖，如果未獲取到，會一定程度的自旋（如果超過一定次數，當前線程會阻塞），這一過程是在scanAndLockForPut()方法中完成的；如果獲取到了鎖，則計算需要新增的節點位於哪一個鏈表，並獲得該鏈表的第一個節點，即first變量，然後遍歷這個鏈表。如果新增節點的key已經存在於鏈表中，則替換掉value值，修改次數modCount加1，釋放鎖；

如果新增節點的key不在鏈表中，則判斷ConcurrentHashMap存儲的元素數量是否大於threshold閾值，且小於最大容量，如果是，則進行擴容；否則將新增節點插入鏈表頭部，完成put操作。

---

疑問

第1行 -- >HashEntry<K,V>[] tab = table;
第2行 --->int index = (tab.length - 1) & hash;
第3行 --->HashEntry<K,V> first = entryAt(tab, index);

對於上面的代碼：爲什麼不直接使用table變量？

有的資料上說，因爲table是volatile變量，使用起來會消耗較多的資源（寫：立即寫入主內存；讀：從主內存中獲取）。

但是，怎麼保證第2行和第3行使用的tab變量和table變量保存一致性？

---

4、rehash()方法

private void rehash(HashEntry<K,V> node) {
            HashEntry<K,V>[] oldTable = table;
            int oldCapacity = oldTable.length;
            int newCapacity = oldCapacity << 1;
            threshold = (int)(newCapacity * loadFactor);
            HashEntry<K,V>[] newTable =
                (HashEntry<K,V>[]) new HashEntry[newCapacity];
            int sizeMask = newCapacity - 1;
            for (int i = 0; i < oldCapacity ; i++) {
                HashEntry<K,V> e = oldTable[i];
                if (e != null) {
                    HashEntry<K,V> next = e.next;
                    int idx = e.hash & sizeMask;
                    if (next == null)   //  Single node on list
                        newTable[idx] = e;
                    else { // Reuse consecutive sequence at same slot
                        HashEntry<K,V> lastRun = e;
                        int lastIdx = idx;
                        for (HashEntry<K,V> last = next;
                             last != null;
                             last = last.next) {
                            int k = last.hash & sizeMask;
                            if (k != lastIdx) {
                                lastIdx = k;
                                lastRun = last;
                            }
                        }
                        newTable[lastIdx] = lastRun;
                        // Clone remaining nodes
                        for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
                            V v = p.value;
                            int h = p.hash;
                            int k = h & sizeMask;
                            HashEntry<K,V> n = newTable[k];
                            newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
                        }
                    }
                }
            }
            int nodeIndex = node.hash & sizeMask; // add the new node
            node.setNext(newTable[nodeIndex]);
            newTable[nodeIndex] = node;
            table = newTable;
        }

這是ConcurrentHashMap擴容方法，將HashEntry數組擴大一倍，將舊數組oldCapacity中的數據移到新數組newCapacity中。

我們知道oldCapacity數組中保存的都是各個鏈表的頭結點。數組擴大後，每個節點都需要重新計算位置。如果鏈表只有一個節點，直接放入新的數組中；對於有多個節點的鏈表，ConcurrentHashMap的處理方式較爲特殊。以一條具體的鏈表爲例子：

經計算得到某個鏈表上的節點新數組的索引位置爲：3、4、3、3，前兩個不用說分別加入第三個HashEntry鏈表、和第四個HashEntry鏈表。但是對於後兩個是屬於同一個鏈表的，所以直接將第三個加入就可以了。

4、size()方法

public int  size() {
         // Try a few times to get accurate count. On failure due to
        // continuous async changes in table, resort to locking.
         final Segment<K,V>[] segments = this.segments;
         int size;
         boolean overflow; // true if size overflows 32 bits
         long sum;         // sum of modCounts
         long last = 0L;   // previous sum
         int retries = -1; // first iteration isn't retry
         try {
             for (;;) {
                 if (retries++ == RETRIES_BEFORE_LOCK) {
                     for (int j = 0; j < segments.length; ++j)
                         ensureSegment(j).lock(); // force creation
                 }
                 sum = 0L;
                 size = 0;
                 overflow = false;
                 for (int j = 0; j < segments.length; ++j) {
                     Segment<K,V> seg = segmentAt(segments, j);
                     if (seg != null) {
                         sum += seg.modCount;
                         int c = seg.count;
                         if (c < 0 || (size += c) < 0)
                             overflow = true;
                     }
                 }
                 if (sum == last)
                     break;
                 last = sum;
             }
         } finally {
             if (retries > RETRIES_BEFORE_LOCK) {
                 for (int j = 0; j < segments.length; ++j)
                     segmentAt(segments, j).unlock();
             }
         }
         return overflow ? Integer.MAX_VALUE : size;
     }

計算ConcurrentHashMap的元素大小是一個有趣的問題，因爲他是併發操作的，就是在你計算size的時候，他還在併發的插入數據，可能會導致你計算出來的size和你實際的size有相差（在你return size的時候，插入了多個數據），要解決這個問題，JDK1.7版本用兩種方案。

1. 第一種方案他會使用不加鎖的模式去嘗試多次計算ConcurrentHashMap的size，最多三次，比較前後兩次計算的結果，結果一致就認爲當前沒有元素加入，計算的結果是準確的；
2. 第二種方案是如果第一種方案不符合，他就會給每個Segment加上鎖，然後計算ConcurrentHashMap的size返回。

參考資料：
Doug Lea：《Java併發編程實戰》
方騰飛：《Java併發編程的藝術》