ConcurrentHashMap源碼分析思惟導圖

源碼解析

put方法源碼

public V put(K key, V value) {
    return putVal(key, value, false);
}

/** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = spread(key.hashCode()); //計算hash值
    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值對應的數組下標獲得第一個節點; 以volatile讀的方式來讀取table數組中的元素，保證每次拿到的數據都是最新的
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            //若是該下標返回的節點爲空，則直接經過cas將新的值封裝成node插入便可；若是cas失敗，說明存在競爭，則進入下一次循環
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);//協助擴容
        else {//進入到這個分支，說明f是當前nodes數組對應位置節點的頭節點，而且不爲空
            V oldVal = null;
            synchronized (f) {//給對應的頭結點加鎖
                if (tabAt(tab, i) == f) {//再次判斷對應下標位置是否爲f節點
                    if (fh >= 0) {//頭結點的hash值大於0，說明是鏈表
                        binCount = 1;//用來記錄鏈表的長度
                        for (Node<K,V> e = f;; ++binCount) {//遍歷鏈表
                            K ek;
                            //若是發現相同的key，則判斷是否須要進行值的覆蓋
                            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;
                            }
                        }
                    }
                    //若是當前的f節點是一顆紅黑樹
                    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;
                        }
                    }
                }
            }
            if (binCount != 0) {//說明上面在作鏈表操做
                //若是鏈表長度已經達到臨界值8 就須要把鏈表轉換爲樹結構
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)//若是val是被替換的，則返回替換以前的值
                    return oldVal;
                break;
            }
        }
    }
    //將當前ConcurrentHashMap的元素數量加1，有可能觸發transfer操做(擴容)
    addCount(1L, binCount);
    return null;
}

spread計算Hash值

static final int spread(int h) {
    return (h ^ (h >>> 16)) & HASH_BITS;
}

initTable初始化表格

private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        if ((sc = sizeCtl) < 0) //被其餘線程搶佔了初始化的操做,則直接讓出本身的CPU時間片
            Thread.yield(); // lost initialization race; just spin
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            //經過cas操做，將sizeCtl替換爲-1，標識當前線程搶佔到了初始化資格
            try {
                if ((tab = table) == null || tab.length == 0) {
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;//默認初始容量爲16
                    @SuppressWarnings("unchecked")
                    //初始化數組，長度爲16，或者初始化在構造ConcurrentHashMap的時候傳入的長度
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;//將這個數組賦值給table
                    sc = n - (n >>> 2);//計算下次擴容的大小，實際就是當前容量的0.75倍，這裏使用了右移來計算
                }
            } finally {
                sizeCtl = sc;//設置sizeCtl爲sc, 若是默認是16的話，那麼這個時候sc=16*0.75=12
            }
            break;
        }
    }
    return tab;
}

tabAt計算下標

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);
}

addCount計數

private final void addCount(long x, int check) {
    CounterCell[] as; long b, s;
    //判斷counterCells是否爲空，
    // 1. 若是爲空，就經過cas操做嘗試修改baseCount變量，對這個變量進行原子累加操做(作這個操做的意義是：若是在沒有競爭的狀況下，仍然採用baseCount來記錄元素個數)
    // 2. 若是cas失敗說明存在競爭，這個時候不能再採用baseCount來累加，而是經過CounterCell來記錄

    if ((as = counterCells) != null ||
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
        CounterCell a; long v; int m;
        boolean uncontended = true;//是否衝突標識，默認爲沒有衝突
        //這裏有幾個判斷
        // 1. 計數表爲空則直接調用fullAddCount
        // 2. 從計數表中隨機取出一個數組的位置爲空，直接調用fullAddCount
        // 3. 經過CAS修改CounterCell隨機位置的值，若是修改失敗說明出現併發狀況（這裏又用到了一種巧妙的方法），
        //    調用fullAndCount Random在線程併發的時候會有性能問題以及可能會產生相同的隨機數,ThreadLocalRandom.getProbe能夠解決這個問題，而且性能要比Random高
        if (as == null || (m = as.length - 1) < 0 ||
            (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
            !(uncontended =
              U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
            fullAddCount(x, uncontended);
            return;
        }
        if (check <= 1)//鏈表長度小於等於1，不須要考慮擴容
            return;
        s = sumCount();//統計ConcurrentHashMap元素個數
    }
    if (check >= 0) {//若是binCount>=0，標識須要檢查擴容
        Node<K,V>[] tab, nt; int n, sc;
        //s標識集合大小，若是集合大小大於或等於擴容閾值（默認值的0.75）
        // 而且table不爲空而且table的長度小於最大容量
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
               (n = tab.length) < MAXIMUM_CAPACITY) {
            int rs = resizeStamp(n);//這裏是生成一個惟一的擴容戳
            if (sc < 0) {
                //sc<0，也就是sizeCtl<0，說明已經有別的線程正在擴容了
                // 這5個條件只要有一個條件爲true，說明當前線程不能幫助進行這次的擴容，直接跳出循環
                // sc >>> RESIZE_STAMP_SHIFT!=rs 表示比較高RESIZE_STAMP_BITS位生成戳和rs是否相等，相同
                // sc=rs+1 表示擴容結束
                // sc==rs+MAX_RESIZERS 表示幫助線程線程已經達到最大值了
                // nt=nextTable -> 表示擴容已經結束
                // transferIndex<=0 表示全部的transfer任務都被領取完了，沒有剩餘的hash桶來給本身本身好這個線程來作transfer
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                    transferIndex <= 0)
                    break;
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))//當前線程嘗試幫助這次擴容，若是成功，則調用transfer
                    transfer(tab, nt);
            }
            //若是當前沒有在擴容，那麼 rs 確定是一個正數，經過 rs <<RESIZE_STAMP_SHIFT 將 sc 設置
            // 爲一個負數， 2 表示有一個線程在執行擴容
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
            s = sumCount();// 從新計數，判斷是否須要開啓下一輪擴容
        }
    }
}

sumCount計數

final long sumCount() {
    CounterCell[] as = counterCells; CounterCell a;
    long sum = baseCount;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

fullAddCount源碼分析

private final void fullAddCount(long x, boolean wasUncontended) {
    int h;
    //獲取當前線程的probe的值，若是值爲0，則初始化當前線程的probe的值,probe就是隨機數
    if ((h = ThreadLocalRandom.getProbe()) == 0) {
        ThreadLocalRandom.localInit();      // force initialization
        h = ThreadLocalRandom.getProbe();
        wasUncontended = true;// 因爲從新生成了probe，未衝突標誌位設置爲true
    }
    boolean collide = false;                // True if last slot nonempty
    for (;;) {
        CounterCell[] as; CounterCell a; int n; long v;
        //說明counterCells已經被初始化過了
        if ((as = counterCells) != null && (n = as.length) > 0) {
            if ((a = as[(n - 1) & h]) == null) {//經過該值與當前線程probe求與，得到cells的下標元素，和hash 表獲取索引是同樣的
                if (cellsBusy == 0) {            // Try to attach new Cell //cellsBusy=0表示counterCells不在初始化或者擴容狀態下
                    CounterCell r = new CounterCell(x); // Optimistic create //構造一個CounterCell的值，傳入元素個數
                    if (cellsBusy == 0 && //經過cas設置cellsBusy標識，防止其餘線程來對counterCells併發處理
                        U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                        boolean created = false;
                        try {               // Recheck under lock
                            CounterCell[] rs; int m, j;
                            //將初始化的r對象的元素個數放在對應下標的位置
                            if ((rs = counterCells) != null &&
                                (m = rs.length) > 0 &&
                                rs[j = (m - 1) & h] == null) {
                                rs[j] = r;
                                created = true;
                            }
                        } finally {//恢復標誌位
                            cellsBusy = 0;
                        }
                        if (created)//建立成功，退出循環
                            break;
                        continue;           // Slot is now non-empty //說明指定cells下標位置的數據不爲空，則進行下一次循環
                    }
                }
                collide = false;
            }
            //說明在addCount方法中cas失敗了，而且獲取probe的值不爲空
            else if (!wasUncontended)       // CAS already known to fail
                wasUncontended = true;      // Continue after rehash//設置爲未衝突標識，進入下一次自旋
            else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))//因爲指定下標位置的cell值不爲空，則直接經過cas進行原子累加，若是成功，則直接退出
                break;
            else if (counterCells != as || n >= NCPU)//若是已經有其餘線程創建了新的counterCells或者CounterCells大於CPU核心數（很巧妙，線程的併發數不會超過cpu核心數）
                collide = false;            // At max size or stale //設置當前線程的循環失敗不進行擴容
            else if (!collide)//恢復collide狀態，標識下次循環會進行擴容
                collide = true;
            else if (cellsBusy == 0 &&//進入這個步驟，說明CounterCell數組容量不夠，線程競爭較大，因此先設置一個標識表示爲正在擴容 else
                     U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                try {
                    if (counterCells == as) {// Expand table unless stale
                        //擴容一倍 2變成4，這個擴容比較簡單
                        CounterCell[] rs = new CounterCell[n << 1];
                        for (int i = 0; i < n; ++i)
                            rs[i] = as[i];
                        counterCells = rs;
                    }
                } finally {
                    cellsBusy = 0;//恢復標識
                }
                collide = false;
                continue;                   // Retry with expanded table //繼續下一次自旋
            }
            h = ThreadLocalRandom.advanceProbe(h);//更新隨機數的值
        }
        else if (cellsBusy == 0 && counterCells == as && //cellsBusy=0表示沒有在作初始化，經過cas更新cellsbusy的值標註當前線程正在作初始化操做
                 U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
            boolean init = false;
            try {                           // Initialize table
                if (counterCells == as) {
                    CounterCell[] rs = new CounterCell[2];//初始化容量爲2
                    rs[h & 1] = new CounterCell(x);//將x也就是元素的個數放在指定的數組下標位置
                    counterCells = rs;//賦值給counterCells
                    init = true;//設置初始化完成標識
                }
            } finally {
                cellsBusy = 0;//恢復標識
            }
            if (init)
                break;
        }
        else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))//競爭激烈，其它線程佔據cell 數組，直接累加在base變量中
            break;                          // Fall back on using base
    }
}

transfer擴容

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    int n = tab.length, stride;
    //將 (n>>>3至關於 n/8) 而後除以 CPU核心數。若是獲得的結果小於 16，那麼就使用 16
    // 這裏的目的是讓每一個 CPU 處理的桶同樣多，避免出現轉移任務不均勻的現象，若是桶較少的話，默認一個 CPU（一個線程）處理 16 個桶，也就是長度爲16的時候，擴容的時候只會有一個線程來擴容
    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
        stride = MIN_TRANSFER_STRIDE; // subdivide range
    //nextTab未初始化，nextTab是用來擴容的node數組
    if (nextTab == null) {            // initiating
        try {
            @SuppressWarnings("unchecked")
            //新建一個n<<1原始table大小的nextTab,也就是32
            Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
            nextTab = nt;//賦值給nextTab
        } catch (Throwable ex) {      // try to cope with OOME
            sizeCtl = Integer.MAX_VALUE;//擴容失敗，sizeCtl使用int的最大值
            return;
        }
        nextTable = nextTab;//更新成員變量
        transferIndex = n;//更新轉移下標，表示轉移時的下標
    }
    int nextn = nextTab.length;//新的tab的長度
    // 建立一個 fwd 節點，表示一個正在被遷移的Node，而且它的hash值爲-1(MOVED)，
    // 也就是前面咱們在講putval方法的時候，會有一個判斷MOVED的邏輯。
    // 它的做用是用來佔位，表示原數組中位置i處的節點完成遷移之後，
    // 就會在i位置設置一個fwd來告訴其餘線程這個位置已經處理過了，具體後續還會在講
    ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
    // 首次推動爲 true，若是等於 true，說明須要再次推動一個下標（i--），反之，若是是 false，那麼就不能推動下標，須要將當前的下標處理完畢才能繼續推動
    boolean advance = true;
    //判斷是否已經擴容完成，完成就return，退出循環
    boolean finishing = false; // to ensure sweep before committing nextTab
    //經過for自循環處理每一個槽位中的鏈表元素，默認advace爲真，經過CAS設置transferIndex屬性值，
    // 並初始化i和bound值，i指當前處理的槽位序號，bound指須要處理的槽位邊界，先處理槽位15的節點；
    for (int i = 0, bound = 0;;) {
        // 這個循環使用CAS不斷嘗試爲當前線程分配任務
        // 直到分配成功或任務隊列已經被所有分配完畢
        // 若是當前線程已經被分配過bucket區域
        // 那麼會經過--i指向下一個待處理bucket而後退出該循環
        Node<K,V> f; int fh;
        while (advance) {
            int nextIndex, nextBound;
            //--i表示下一個待處理的bucket，若是它>=bound,表示當前線程已經分配過bucket區域
            if (--i >= bound || finishing)
                advance = false;
            else if ((nextIndex = transferIndex) <= 0) {//表示全部bucket已經被分配完畢
                i = -1;
                advance = false;
            }
            //經過cas來修改TRANSFERINDEX,爲當前線程分配任務，處理的節點區間爲(nextBound,nextIndex)->(0,15)
            else if (U.compareAndSwapInt
                     (this, TRANSFERINDEX, nextIndex,
                      nextBound = (nextIndex > stride ?
                                   nextIndex - stride : 0))) {
                bound = nextBound;
                i = nextIndex - 1;
                advance = false;
            }
        }
        //i<0說明已經遍歷完舊的數組，也就是當前線程已經處理完全部負責的bucket
        if (i < 0 || i >= n || i + n >= nextn) {
            int sc;
            if (finishing) {//若是完成了擴容
                nextTable = null;//刪除成員變量
                table = nextTab;//更新table數組
                sizeCtl = (n << 1) - (n >>> 1);//更新閾值(32*0.75=24)
                return;
            }
            // sizeCtl 在遷移前會設置爲 (rs << RESIZE_STAMP_SHIFT) + 2
            // 而後，每增長一個線程參與遷移就會將 sizeCtl 加 1， // 這裏使用 CAS 操做對 sizeCtl 的低16位進行減 1，表明作完了屬於本身的任務
            if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                //第一個擴容的線程，執行transfer方法以前，會設置 sizeCtl = (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2)
                // 後續幫其擴容的線程，執行transfer方法以前，會設置 sizeCtl = sizeCtl+1 每個退出transfer的方法的線程，退出以前，
                // 會設置 sizeCtl = sizeCtl-1 那麼最後一個線程退出時：必然有 sc == (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2)，
                // 即 (sc - 2) == resizeStamp(n) << RESIZE_STAMP_SHIFT // 若是 sc - 2 不等於標識符左移 16 位。若是他們相等了，
                // 說明沒有線程在幫助他們擴容了。也就是說，擴容結束了。
                if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                    return;
                // 若是相等，擴容結束了，更新 finising 變量
                finishing = advance = true;
                // 再次循環檢查一下整張表
                i = n; // recheck before commit
            }
        }
        // 若是位置 i 處是空的，沒有任何節點，那麼放入剛剛初始化的 ForwardingNode 」空節點「
        else if ((f = tabAt(tab, i)) == null)
            advance = casTabAt(tab, i, null, fwd);
        //表示該位置已經完成了遷移，也就是若是線程A已經處理過這個節點，那麼線程B處理這個節點時，hash值必定爲MOVED
        else if ((fh = f.hash) == MOVED)
            advance = true; // already processed
        else {
            synchronized (f) {//對數組該節點位置加鎖，開始處理數組該位置的遷移工做
                if (tabAt(tab, i) == f) {
                    Node<K,V> ln, hn;///ln 表示低位， hn 表示高位 接下來這段代碼的做用 是把鏈表拆分紅兩部分， 0 在低位， 1 在高位
                    if (fh >= 0) {
                        int runBit = fh & n;
                        Node<K,V> lastRun = f;
                        //遍歷當前bucket的鏈表，目的是儘可能重用Node鏈表尾部的一部分
                        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) {//若是最後更新的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);
                        }
                        setTabAt(nextTab, i, ln);//將低位的鏈表放在 i 位置也就是不動
                        setTabAt(nextTab, i + n, hn);//將高位鏈表放在 i+n 位置
                        setTabAt(tab, i, fwd);// 把舊 table 的 hash 桶中放置轉發節點，代表此 hash 桶已經被處理
                        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;
                            }
                        }
                        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;
                        setTabAt(nextTab, i, ln);
                        setTabAt(nextTab, i + n, hn);
                        setTabAt(tab, i, fwd);
                        advance = true;
                    }
                }
            }
        }
    }
}

resizeStamp

static final int resizeStamp(int n) { return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1)); }

helpTransfer

private final void tryPresize(int size) {
    //對size進行修復,主要目的是防止傳入的值不是一個2次冪的整數，而後經過tableSizeFor來說入參轉化爲離該整數最近的2次冪
    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;
        //下面這段代碼和initTable是同樣的，若是table沒有初始化，則開始初始化
        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);
                    }
                } finally {
                    sizeCtl = sc;
                }
            }
        }
        else if (c <= sc || n >= MAXIMUM_CAPACITY)
            break;
        else if (tab == table) { //這段代碼和addCount後部分代碼是同樣的，作輔助擴容操做
            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;
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
        }
    }
}

treeifyBin

private final void treeifyBin(Node<K,V>[] tab, int index) {
    Node<K,V> b; int n, sc;
    if (tab != null) {
        if ((n = tab.length) < MIN_TREEIFY_CAPACITY)//tab的長度是否是小於64，若是是，則執行擴容
            tryPresize(n << 1);
        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

private final void tryPresize(int size) {
    //對size進行修復,主要目的是防止傳入的值不是一個2次冪的整數，而後經過tableSizeFor來說入參轉化爲離該整數最近的2次冪
    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;
        //下面這段代碼和initTable是同樣的，若是table沒有初始化，則開始初始化
        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);
                    }
                } finally {
                    sizeCtl = sc;
                }
            }
        }
        else if (c <= sc || n >= MAXIMUM_CAPACITY)
            break;
        else if (tab == table) { //這段代碼和addCount後部分代碼是同樣的，作輔助擴容操做
            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;
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
        }
    }
}