Java併發指南13：Java7/8 中的 HashMap 和 ConcurrentHashMap 全解析

Java7/8 中的 HashMap 和 ConcurrentHashMap 全解析

轉自https://www.javadoop.com/post...

部份內容轉自

http://www.jasongj.com/java/c...

今天發一篇"水文"，可能不少讀者都會表示不理解，不過我想把它做爲併發序列文章中不可缺乏的一塊來介紹。原本覺得花不了多少時間的，不過最終仍是投入了挺多時間來完成這篇文章的。

網上關於 HashMap 和 ConcurrentHashMap 的文章確實很多，不過缺斤少兩的文章比較多，因此纔想本身也寫一篇，把細節說清楚說透，尤爲像 Java8 中的 ConcurrentHashMap，大部分文章都說不清楚。終歸是但願能下降你們學習的成本，不但願你們處處找各類不是很靠譜的文章，看完一篇又一篇，但是仍是模模糊糊。

閱讀建議：四節基本上能夠進行獨立閱讀，建議初學者可按照 Java7 HashMap -> Java7 ConcurrentHashMap -> Java8 HashMap -> Java8 ConcurrentHashMap 順序進行閱讀，可適當下降閱讀門檻。

閱讀前提：本文分析的是源碼，因此至少讀者要熟悉它們的接口使用，同時，對於併發，讀者至少要知道 CAS、ReentrantLock、UNSAFE 操做這幾個基本的知識，文中不會對這些知識進行介紹。Java8 用到了紅黑樹，不過本文不會進行展開，感興趣的讀者請自行查找相關資料。

 

// 這構造函數裏，什麼都不幹
public ConcurrentHashMap() {
}
public ConcurrentHashMap(int initialCapacity) {

if (initialCapacity < 0)
    throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
           MAXIMUM_CAPACITY :
           tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;

}
這個初始化方法有點意思，經過提供初始容量，計算了 sizeCtl，sizeCtl = 【 (1.5 * initialCapacity + 1)，而後向上取最近的 2 的 n 次方】。如 initialCapacity 爲 10，那麼獲得 sizeCtl 爲 16，若是 initialCapacity 爲 11，獲得 sizeCtl 爲 32。

sizeCtl 這個屬性使用的場景不少，不過只要跟着文章的思路來，就不會被它搞暈了。

若是你愛折騰，也能夠看下另外一個有三個參數的構造方法，這裏我就不說了，大部分時候，咱們會使用無參構造函數進行實例化，咱們也按照這個思路來進行源碼分析吧。

put 過程分析
仔細地一行一行代碼看下去：

public V put(K key, V value) {

return putVal(key, value, false);

}
final V putVal(K key, V value, boolean onlyIfAbsent) {

if (key == null || value == null) throw new NullPointerException();
// 獲得 hash 值
int hash = spread(key.hashCode());
// 用於記錄相應鏈表的長度
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();

    // 找該 hash 值對應的數組下標，獲得第一個節點 f
    else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
        // 若是數組該位置爲空，
        //    用一次 CAS 操做將這個新值放入其中便可，這個 put 操做差很少就結束了，能夠拉到最後面了
        //          若是 CAS 失敗，那就是有併發操做，進到下一個循環就行了
        if (casTabAt(tab, i, null,
                     new Node<K,V>(hash, key, value, null)))
            break;                   // no lock when adding to empty bin
    }
    // hash 竟然能夠等於 MOVED，這個須要到後面才能看明白，不過從名字上也能猜到，確定是由於在擴容
    else if ((fh = f.hash) == MOVED)
        // 幫助數據遷移，這個等到看完數據遷移部分的介紹後，再理解這個就很簡單了
        tab = helpTransfer(tab, f);

    else { // 到這裏就是說，f 是該位置的頭結點，並且不爲空

        V oldVal = null;
        // 獲取數組該位置的頭結點的監視器鎖
        synchronized (f) {
            if (tabAt(tab, i) == f) {
                if (fh >= 0) { // 頭結點的 hash 值大於 0，說明是鏈表
                    // 用於累加，記錄鏈表的長度
                    binCount = 1;
                    // 遍歷鏈表
                    for (Node<K,V> e = f;; ++binCount) {
                        K ek;
                        // 若是發現了"相等"的 key，判斷是否要進行值覆蓋，而後也就能夠 break 了
                        if (e.hash == hash &&
                            ((ek = e.key) == key ||
                             (ek != null && key.equals(ek)))) {
                            oldVal = e.val;
                            if (!onlyIfAbsent)
                                e.val = value;
                            break;
                        }
                        // 到了鏈表的最末端，將這個新值放到鏈表的最後面
                        Node<K,V> pred = e;
                        if ((e = e.next) == null) {
                            pred.next = new Node<K,V>(hash, key,
                                                      value, null);
                            break;
                        }
                    }
                }
                else if (f instanceof TreeBin) { // 紅黑樹
                    Node<K,V> p;
                    binCount = 2;
                    // 調用紅黑樹的插值方法插入新節點
                    if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                   value)) != null) {
                        oldVal = p.val;
                        if (!onlyIfAbsent)
                            p.val = value;
                    }
                }
            }
        }
        // binCount != 0 說明上面在作鏈表操做
        if (binCount != 0) {
            // 判斷是否要將鏈表轉換爲紅黑樹，臨界值和 HashMap 同樣，也是 8
            if (binCount >= TREEIFY_THRESHOLD)
                // 這個方法和 HashMap 中稍微有一點點不一樣，那就是它不是必定會進行紅黑樹轉換，
                // 若是當前數組的長度小於 64，那麼會選擇進行數組擴容，而不是轉換爲紅黑樹
                //    具體源碼咱們就不看了，擴容部分後面說
                treeifyBin(tab, i);
            if (oldVal != null)
                return oldVal;
            break;
        }
    }
}
// 
addCount(1L, binCount);
return null;

}
put 的主流程看完了，可是至少留下了幾個問題，第一個是初始化，第二個是擴容，第三個是幫助數據遷移，這些咱們都會在後面進行一一介紹。

初始化數組：initTable

這個比較簡單，主要就是初始化一個合適大小的數組，而後會設置 sizeCtl。

初始化方法中的併發問題是經過對 sizeCtl 進行一個 CAS 操做來控制的。

private final Node<K,V>[] initTable() {

Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
    // 初始化的"功勞"被其餘線程"搶去"了
    if ((sc = sizeCtl) < 0)
        Thread.yield(); // lost initialization race; just spin
    // CAS 一下，將 sizeCtl 設置爲 -1，表明搶到了鎖
    else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
        try {
            if ((tab = table) == null || tab.length == 0) {
                // DEFAULT_CAPACITY 默認初始容量是 16
                int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                // 初始化數組，長度爲 16 或初始化時提供的長度
                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                // 將這個數組賦值給 table，table 是 volatile 的
                table = tab = nt;
                // 若是 n 爲 16 的話，那麼這裏 sc = 12
                // 其實就是 0.75 * n
                sc = n - (n >>> 2);
            }
        } finally {
            // 設置 sizeCtl 爲 sc，咱們就當是 12 吧
            sizeCtl = sc;
        }
        break;
    }
}
return tab;

}
鏈表轉紅黑樹: treeifyBin

前面咱們在 put 源碼分析也說過，treeifyBin 不必定就會進行紅黑樹轉換，也多是僅僅作數組擴容。咱們仍是進行源碼分析吧。

private final void treeifyBin(Node<K,V>[] tab, int index) {

Node<K,V> b; int n, sc;
if (tab != null) {
    // MIN_TREEIFY_CAPACITY 爲 64
    // 因此，若是數組長度小於 64 的時候，其實也就是 32 或者 16 或者更小的時候，會進行數組擴容
    if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
        // 後面咱們再詳細分析這個方法
        tryPresize(n << 1);
    // b 是頭結點
    else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
        // 加鎖
        synchronized (b) {

            if (tabAt(tab, index) == b) {
                // 下面就是遍歷鏈表，創建一顆紅黑樹
                TreeNode<K,V> hd = null, tl = null;
                for (Node<K,V> e = b; e != null; e = e.next) {
                    TreeNode<K,V> p =
                        new TreeNode<K,V>(e.hash, e.key, e.val,
                                          null, null);
                    if ((p.prev = tl) == null)
                        hd = p;
                    else
                        tl.next = p;
                    tl = p;
                }
                // 將紅黑樹設置到數組相應位置中
                setTabAt(tab, index, new TreeBin<K,V>(hd));
            }
        }
    }
}

}
擴容：tryPresize
若是說 Java8 ConcurrentHashMap 的源碼不簡單，那麼說的就是擴容操做和遷移操做。

這個方法要完徹底全看懂還須要看以後的 transfer 方法，讀者應該提早知道這點。

這裏的擴容也是作翻倍擴容的，擴容後數組容量爲原來的 2 倍。

// 首先要說明的是，方法參數 size 傳進來的時候就已經翻了倍了
private final void tryPresize(int size) {

// c：size 的 1.5 倍，再加 1，再往上取最近的 2 的 n 次方。
int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
    tableSizeFor(size + (size >>> 1) + 1);
int sc;
while ((sc = sizeCtl) >= 0) {
    Node<K,V>[] tab = table; int n;

    // 這個 if 分支和以前說的初始化數組的代碼基本上是同樣的，在這裏，咱們能夠不用管這塊代碼
    if (tab == null || (n = tab.length) == 0) {
        n = (sc > c) ? sc : c;
        if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                if (table == tab) {
                    @SuppressWarnings("unchecked")
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = nt;
                    sc = n - (n >>> 2); // 0.75 * n
                }
            } finally {
                sizeCtl = sc;
            }
        }
    }
    else if (c <= sc || n >= MAXIMUM_CAPACITY)
        break;
    else if (tab == table) {
        // 我沒看懂 rs 的真正含義是什麼，不過也關係不大
        int rs = resizeStamp(n);

        if (sc < 0) {
            Node<K,V>[] nt;
            if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                transferIndex <= 0)
                break;
            // 2. 用 CAS 將 sizeCtl 加 1，而後執行 transfer 方法
            //    此時 nextTab 不爲 null
            if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                transfer(tab, nt);
        }
        // 1. 將 sizeCtl 設置爲 (rs << RESIZE_STAMP_SHIFT) + 2)
        //     我是沒看懂這個值真正的意義是什麼？不過能夠計算出來的是，結果是一個比較大的負數
        //  調用 transfer 方法，此時 nextTab 參數爲 null
        else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                     (rs << RESIZE_STAMP_SHIFT) + 2))
            transfer(tab, null);
    }
}

}
這個方法的核心在於 sizeCtl 值的操做，首先將其設置爲一個負數，而後執行 transfer(tab, null)，再下一個循環將 sizeCtl 加 1，並執行 transfer(tab, nt)，以後多是繼續 sizeCtl 加 1，並執行 transfer(tab, nt)。

因此，可能的操做就是執行 1 次 transfer(tab, null) + 屢次 transfer(tab, nt)，這裏怎麼結束循環的須要看完 transfer 源碼才清楚。

數據遷移：transfer

下面這個方法很點長，將原來的 tab 數組的元素遷移到新的 nextTab 數組中。

雖然咱們以前說的 tryPresize 方法中屢次調用 transfer 不涉及多線程，可是這個 transfer 方法能夠在其餘地方被調用，典型地，咱們以前在說 put 方法的時候就說過了，請往上看 put 方法，是否是有個地方調用了 helpTransfer 方法，helpTransfer 方法會調用 transfer 方法的。

此方法支持多線程執行，外圍調用此方法的時候，會保證第一個發起數據遷移的線程，nextTab 參數爲 null，以後再調用此方法的時候，nextTab 不會爲 null。

閱讀源碼以前，先要理解併發操做的機制。原數組長度爲 n，因此咱們有 n 個遷移任務，讓每一個線程每次負責一個小任務是最簡單的，每作完一個任務再檢測是否有其餘沒作完的任務，幫助遷移就能夠了，而 Doug Lea 使用了一個 stride，簡單理解就是步長，每一個線程每次負責遷移其中的一部分，如每次遷移 16 個小任務。因此，咱們就須要一個全局的調度者來安排哪一個線程執行哪幾個任務，這個就是屬性 transferIndex 的做用。

第一個發起數據遷移的線程會將 transferIndex 指向原數組最後的位置，而後從後往前的 stride 個任務屬於第一個線程，而後將 transferIndex 指向新的位置，再往前的 stride 個任務屬於第二個線程，依此類推。固然，這裏說的第二個線程不是真的必定指代了第二個線程，也能夠是同一個線程，這個讀者應該能理解吧。其實就是將一個大的遷移任務分爲了一個個任務包。

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {

int n = tab.length, stride;

// stride 在單核下直接等於 n，多核模式下爲 (n>>>3)/NCPU，最小值是 16
// stride 能夠理解爲」步長「，有 n 個位置是須要進行遷移的，
//   將這 n 個任務分爲多個任務包，每一個任務包有 stride 個任務
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
    stride = MIN_TRANSFER_STRIDE; // subdivide range

// 若是 nextTab 爲 null，先進行一次初始化
//    前面咱們說了，外圍會保證第一個發起遷移的線程調用此方法時，參數 nextTab 爲 null
//       以後參與遷移的線程調用此方法時，nextTab 不會爲 null
if (nextTab == null) {
    try {
        // 容量翻倍
        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
        nextTab = nt;
    } catch (Throwable ex) {      // try to cope with OOME
        sizeCtl = Integer.MAX_VALUE;
        return;
    }
    // nextTable 是 ConcurrentHashMap 中的屬性
    nextTable = nextTab;
    // transferIndex 也是 ConcurrentHashMap 的屬性，用於控制遷移的位置
    transferIndex = n;
}

int nextn = nextTab.length;

// ForwardingNode 翻譯過來就是正在被遷移的 Node
// 這個構造方法會生成一個Node，key、value 和 next 都爲 null，關鍵是 hash 爲 MOVED
// 後面咱們會看到，原數組中位置 i 處的節點完成遷移工做後，
//    就會將位置 i 處設置爲這個 ForwardingNode，用來告訴其餘線程該位置已經處理過了
//    因此它其實至關因而一個標誌。
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);


// advance 指的是作完了一個位置的遷移工做，能夠準備作下一個位置的了
boolean advance = true;
boolean finishing = false; // to ensure sweep before committing nextTab

/*
 * 下面這個 for 循環，最難理解的在前面，而要看懂它們，應該先看懂後面的，而後再倒回來看
 * 
 */

// i 是位置索引，bound 是邊界，注意是從後往前
for (int i = 0, bound = 0;;) {
    Node<K,V> f; int fh;

    // 下面這個 while 真的是很差理解
    // advance 爲 true 表示能夠進行下一個位置的遷移了
    //   簡單理解結局：i 指向了 transferIndex，bound 指向了 transferIndex-stride
    while (advance) {
        int nextIndex, nextBound;
        if (--i >= bound || finishing)
            advance = false;

        // 將 transferIndex 值賦給 nextIndex
        // 這裏 transferIndex 一旦小於等於 0，說明原數組的全部位置都有相應的線程去處理了
        else if ((nextIndex = transferIndex) <= 0) {
            i = -1;
            advance = false;
        }
        else if (U.compareAndSwapInt
                 (this, TRANSFERINDEX, nextIndex,
                  nextBound = (nextIndex > stride ?
                               nextIndex - stride : 0))) {
            // 看括號中的代碼，nextBound 是此次遷移任務的邊界，注意，是從後往前
            bound = nextBound;
            i = nextIndex - 1;
            advance = false;
        }
    }
    if (i < 0 || i >= n || i + n >= nextn) {
        int sc;
        if (finishing) {
            // 全部的遷移操做已經完成
            nextTable = null;
            // 將新的 nextTab 賦值給 table 屬性，完成遷移
            table = nextTab;
            // 從新計算 sizeCtl：n 是原數組長度，因此 sizeCtl 得出的值將是新數組長度的 0.75 倍
            sizeCtl = (n << 1) - (n >>> 1);
            return;
        }

        // 以前咱們說過，sizeCtl 在遷移前會設置爲 (rs << RESIZE_STAMP_SHIFT) + 2
        // 而後，每有一個線程參與遷移就會將 sizeCtl 加 1，
        // 這裏使用 CAS 操做對 sizeCtl 進行減 1，表明作完了屬於本身的任務
        if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
            // 任務結束，方法退出
            if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                return;

            // 到這裏，說明 (sc - 2) == resizeStamp(n) << RESIZE_STAMP_SHIFT，
            // 也就是說，全部的遷移任務都作完了，也就會進入到上面的 if(finishing){} 分支了
            finishing = advance = true;
            i = n; // recheck before commit
        }
    }
    // 若是位置 i 處是空的，沒有任何節點，那麼放入剛剛初始化的 ForwardingNode 」空節點「
    else if ((f = tabAt(tab, i)) == null)
        advance = casTabAt(tab, i, null, fwd);
    // 該位置處是一個 ForwardingNode，表明該位置已經遷移過了
    else if ((fh = f.hash) == MOVED)
        advance = true; // already processed
    else {
        // 對數組該位置處的結點加鎖，開始處理數組該位置處的遷移工做
        synchronized (f) {
            if (tabAt(tab, i) == f) {
                Node<K,V> ln, hn;
                // 頭結點的 hash 大於 0，說明是鏈表的 Node 節點
                if (fh >= 0) {
                    // 下面這一塊和 Java7 中的 ConcurrentHashMap 遷移是差很少的，
                    // 須要將鏈表一分爲二，
                    //   找到原鏈表中的 lastRun，而後 lastRun 及其以後的節點是一塊兒進行遷移的
                    //   lastRun 以前的節點須要進行克隆，而後分到兩個鏈表中
                    int runBit = fh & n;
                    Node<K,V> lastRun = f;
                    for (Node<K,V> p = f.next; p != null; p = p.next) {
                        int b = p.hash & n;
                        if (b != runBit) {
                            runBit = b;
                            lastRun = p;
                        }
                    }
                    if (runBit == 0) {
                        ln = lastRun;
                        hn = null;
                    }
                    else {
                        hn = lastRun;
                        ln = null;
                    }
                    for (Node<K,V> p = f; p != lastRun; p = p.next) {
                        int ph = p.hash; K pk = p.key; V pv = p.val;
                        if ((ph & n) == 0)
                            ln = new Node<K,V>(ph, pk, pv, ln);
                        else
                            hn = new Node<K,V>(ph, pk, pv, hn);
                    }
                    // 其中的一個鏈表放在新數組的位置 i
                    setTabAt(nextTab, i, ln);
                    // 另外一個鏈表放在新數組的位置 i+n
                    setTabAt(nextTab, i + n, hn);
                    // 將原數組該位置處設置爲 fwd，表明該位置已經處理完畢，
                    //    其餘線程一旦看到該位置的 hash 值爲 MOVED，就不會進行遷移了
                    setTabAt(tab, i, fwd);
                    // advance 設置爲 true，表明該位置已經遷移完畢
                    advance = true;
                }
                else if (f instanceof TreeBin) {
                    // 紅黑樹的遷移
                    TreeBin<K,V> t = (TreeBin<K,V>)f;
                    TreeNode<K,V> lo = null, loTail = null;
                    TreeNode<K,V> hi = null, hiTail = null;
                    int lc = 0, hc = 0;
                    for (Node<K,V> e = t.first; e != null; e = e.next) {
                        int h = e.hash;
                        TreeNode<K,V> p = new TreeNode<K,V>
                            (h, e.key, e.val, null, null);
                        if ((h & n) == 0) {
                            if ((p.prev = loTail) == null)
                                lo = p;
                            else
                                loTail.next = p;
                            loTail = p;
                            ++lc;
                        }
                        else {
                            if ((p.prev = hiTail) == null)
                                hi = p;
                            else
                                hiTail.next = p;
                            hiTail = p;
                            ++hc;
                        }
                    }
                    // 若是一分爲二後，節點數少於 8，那麼將紅黑樹轉換回鏈表
                    ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                        (hc != 0) ? new TreeBin<K,V>(lo) : t;
                    hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                        (lc != 0) ? new TreeBin<K,V>(hi) : t;

                    // 將 ln 放置在新數組的位置 i
                    setTabAt(nextTab, i, ln);
                    // 將 hn 放置在新數組的位置 i+n
                    setTabAt(nextTab, i + n, hn);
                    // 將原數組該位置處設置爲 fwd，表明該位置已經處理完畢，
                    //    其餘線程一旦看到該位置的 hash 值爲 MOVED，就不會進行遷移了
                    setTabAt(tab, i, fwd);
                    // advance 設置爲 true，表明該位置已經遷移完畢
                    advance = true;
                }
            }
        }
    }
}

}
說到底，transfer 這個方法並無實現全部的遷移任務，每次調用這個方法只實現了 transferIndex 往前 stride 個位置的遷移工做，其餘的須要由外圍來控制。

這個時候，再回去仔細看 tryPresize 方法可能就會更加清晰一些了。

get 過程分析
get 方法歷來都是最簡單的，這裏也不例外：

計算 hash 值
根據 hash 值找到數組對應位置: (n - 1) & h
根據該位置處結點性質進行相應查找
若是該位置爲 null，那麼直接返回 null 就能夠了
若是該位置處的節點恰好就是咱們須要的，返回該節點的值便可
若是該位置節點的 hash 值小於 0，說明正在擴容，或者是紅黑樹，後面咱們再介紹 find 方法
若是以上 3 條都不知足，那就是鏈表，進行遍歷比對便可
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;
    }
    // 若是頭結點的 hash 小於 0，說明 正在擴容，或者該位置是紅黑樹
    else if (eh < 0)
        // 參考 ForwardingNode.find(int h, Object k) 和 TreeBin.find(int h, Object k)
        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;

}
簡單說一句，此方法的大部份內容都很簡單，只有正好碰到擴容的狀況，ForwardingNode.find(int h, Object k) 稍微複雜一些，不過在瞭解了數據遷移的過程後，這個也就不難了，因此限於篇幅這裏也不展開說了。

 

size操做
put方法和remove方法都會經過addCount方法維護Map的size。size方法經過sumCount獲取由addCount方法維護的Map的size。

 
同步方式
對於put操做，若是Key對應的數組元素爲null，則經過CAS操做將其設置爲當前值。若是Key對應的數組元素（也即鏈表表頭或者樹的根元素）不爲null，則對該元素使用synchronized關鍵字申請鎖，而後進行操做。若是該put操做使得當前鏈表長度超過必定閾值，則將該鏈表轉換爲樹，從而提升尋址效率。

對於讀操做，因爲數組被volatile關鍵字修飾，所以不用擔憂數組的可見性問題。同時每一個元素是一個Node實例（Java 7中每一個元素是一個HashEntry），它的Key值和hash值都由final修飾，不可變動，無須關心它們被修改後的可見性問題。而其Value及對下一個元素的引用由volatile修飾，可見性也有保障。

 
1

2

3

4

5

6

 
static class Node<K,V> implements Map.Entry<K,V> {

final int hash;

final K key;

volatile V val;

volatile Node<K,V> next;

}

對於Key對應的數組元素的可見性，由Unsafe的getObjectVolatile方法保證。

 
1

2

3

 
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {

return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);

}

總結
其實也不是很難嘛，雖然沒有像以前的 AQS 和線程池同樣一行一行源碼進行分析，但仍是把全部初學者可能會糊塗的地方都進行了深刻的介紹，只要是稍微有點基礎的讀者，應該是很容易就能看懂 HashMap 和 ConcurrentHashMap 源碼了。

看源碼不算是目的吧，深刻地瞭解 Doug Lea 的設計思路，我以爲還挺有趣的，大師就是大師，代碼寫得真的是好啊。

我發現不少人都覺得我寫博客主要是源碼分析，說真的，我對於源碼分析沒有那麼大熱情，主要都是爲了用源碼說事罷了，可能以後的文章仍是會有比較多的源碼分析成分，你們該怎麼看就怎麼看吧。

不要臉地自覺得本文的質量仍是挺高的，信息量比較大，若是你以爲有寫得很差的地方，或者說看完本文你仍是沒看懂它們，那麼請提出來~~~

（全文完）

版權聲明：本文爲CSDN博主「黃小斜」的原創文章，遵循CC 4.0 by-sa版權協議，轉載請附上原文出處連接及本聲明。
原文連接：https://blog.csdn.net/a724888...