Java8 ConcurrentHashMap詳解

#Java8 ConcurrentHashMapjava

Java7 中實現的 ConcurrentHashMap 說實話仍是比較複雜的,Java8 對 ConcurrentHashMap 進行了比較大的改動。建議讀者能夠參考 Java8 中 HashMap 相對於 Java7 HashMap 的改動,對於 ConcurrentHashMap,Java8 也引入了紅黑樹。數組

說實話,Java8 ConcurrentHashMap 源碼真心不簡單,最難的在於擴容,數據遷移操做不容易看懂。安全

咱們先用一個示意圖來描述下其結構:微信

4

結構上和 Java8 的 HashMap 基本上同樣,不過它要保證線程安全性,因此在源碼上確實要複雜一些。
##初始化多線程

// 這構造函數裏,什麼都不幹
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 這個屬性使用的場景不少,不過只要跟着文章的思路來,就不會被它搞暈了。ide

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

仔細地一行一行代碼看下去:oop

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) 稍微複雜一些,不過在瞭解了數據遷移的過程後,這個也就不難了,因此限於篇幅這裏也不展開說了。
###總結

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

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

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

出處:https://www.javadoop.com/post/hashmap#Java7%20ConcurrentHashMap
文章有不當之處,歡迎指正,你也能夠關注個人微信公衆號:好好學java,獲取優質資源。

相關文章
相關標籤/搜索