ConcurrentHashMap源碼解析 java8

源碼的學習是有趣的，受益頗多的，你一定能夠獲得驚喜。

前一階段出去面試的時候被問到ConcurrentHashMap，當時回答的時候只是泛泛而談，談了其特點，與jdk 1.7相比的優點等等。但是隱約感覺到面試官不太滿意，後來反思了一下，是沒有深入到源碼層面進行功能實現的解析，導致說出來的話都沒有說服力，因此研究一下，用作記錄和學習。

ConcurrentHashMap主要方法是put與擴容，先說下put方法。

（背景：面試官直接問我：ConcurrentHashMap是怎麼實現線程安全的，是直接在put方法上面加鎖嗎？）

// put方法是直接調用putVal方法的
final V putVal(K key, V value, boolean onlyIfAbsent) {
// key或者value是null就直接拋出空指針
        if (key == null || value == null) throw new NullPointerException();
        // spread方法根據key的hashCode值算出hash值
        int hash = spread(key.hashCode());
        // 鏈表的長度
        int binCount = 0;
        // 循環table，和while(true)一樣，break的時候才能退出，注意這個時候tab是可能爲null或者size==0的
        // 這裏其實就是自旋操作，當出現線程競爭時不斷自旋
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            // tab爲null或者size==0，就初始化tab
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            // 通過hash值對應的數組得到第一個節點；以volatile讀的方式讀取table數組中的元素，保證每次拿到的都是最新的值
            // 如果當前數組的值爲null，就使用cas放入，cas成功返回true，然後break跳出循環，put結束；cas失敗則進行下一次循環。
            //這裏的tabAt和casTabAt都是Unsafe的nativa方法。這兩個方法的源碼的作者使用Unsafe直接通過數組內存地址以及索引偏移量去訪問和修改數組元素的值，和我們直接使用java代碼訪問arr[i]的區別是，java中的數組是經過了包裝的，通過java代碼來訪問避免數組越界異常ArrayIndexOutOfBoundsException。
            // 總結：ConcurrentHashMap中針對table數組的Unsafe訪問和賦值的意義應該是在於越過jvm對數組操作的包裝，進而達到優化性能的目的。
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            --------------------------------------------
            /*假如在上面這段代碼中存在兩個線程，在不加鎖的情況下：
            線程A成功執行casTabAt操作後，隨後的線程B可以通過tabAt方法立刻看到table[i]的改變。
            原因如下：線程A的casTabAt操作，具有volatile讀寫相同的內存語義，
            根據volatile的happens-before規則：線程A的casTabAt操作，一定對線程B的tabAt操作可見*/
            --------------------------------------------
            // 如果達到閾值，則轉移元素，進行擴容
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            // 下面的方法也就是說，數組頭節點有數值，則對頭節點加鎖
            else {
                V oldVal = null;
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                    // 如果是鏈表，遍歷鏈表
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                // 遇到key值==或者equal的key，就替換掉value，結束
                                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;
                                // 或者遍歷直到e.next=null時,結束
                                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;
                            }
                        }
                    }
                }
                // 若鏈表長度是否大於等於8，將鏈表轉換成紅黑樹
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }

ConcurrentHashMap數組擴容是比較難的地方。未完待續～～～

參考文章1：http://www.sohu.com/a/320372210_120176035
參考文章2：https://javadoop.com/post/hashmap