int ssize = 1;
while (ssize < concurrencyLevel) {
    ++sshift;
    ssize <<= 1;
}

int cap = MIN_SEGMENT_TABLE_CAPACITY;
while (cap < c)
    cap <<= 1;

// 默認(rèn)初始值，必須是2的幕數(shù)
private static final int DEFAULT_CAPACITY = 16;
// 負(fù)載因子
private static final float LOAD_FACTOR = 0.75f;
// 鏈表轉(zhuǎn)紅黑樹閥值,> 8 鏈表轉(zhuǎn)換為紅黑樹
static final int TREEIFY_THRESHOLD = 8;
//樹轉(zhuǎn)鏈表閥值，小于等于6 ，僅在擴(kuò)容tranfer時(shí)才可能樹轉(zhuǎn)鏈表
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;
private static final int MIN_TRANSFER_STRIDE = 16;
private static int RESIZE_STAMP_BITS = 16;
// 2^15-1，help resize的最大線程數(shù)
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
// 32-16=16，sizeCtl中記錄size大小的偏移量
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
// forwarding nodes的hash值
static final int MOVED     = -1; 
// 樹根節(jié)點(diǎn)的hash值
static final int TREEBIN   = -2; 
// ReservationNode的hash值
static final int RESERVED  = -3; 
// 可用處理器數(shù)量
static final int NCPU = Runtime.getRuntime().availableProcessors();
//存放node的數(shù)組 第一次插入數(shù)據(jù)的時(shí)候初始化，大小是2的冪次方
transient volatile Node<K,V>[] table;
/*控制標(biāo)識(shí)符，用來控制table的初始化和擴(kuò)容的操作，不同的值有不同的含義
 *當(dāng)為負(fù)數(shù)時(shí)：-1代表正在初始化，-N代表有N-1個(gè)線程正在 進(jìn)行擴(kuò)容
 *當(dāng)為0時(shí)：代表當(dāng)時(shí)的table還沒有被初始化
 *當(dāng)為正數(shù)時(shí)：表示初始化或者下一次進(jìn)行擴(kuò)容的大小
，類似于擴(kuò)容閾值。它的值始終是當(dāng)前ConcurrentHashMap容量的0.75倍，這與loadfactor是對(duì)應(yīng)的。實(shí)際容量>=sizeCtl，則擴(kuò)容。
private transient volatile int sizeCtl;

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，減少hash沖突，可以均勻分布
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) { //對(duì)這個(gè)table進(jìn)行迭代
        Node<K,V> f; int n, i, fh;
        //這里就是上面構(gòu)造方法沒有進(jìn)行初始化，在這里進(jìn)行判斷，為null就調(diào)用initTable進(jìn)行初始化，屬于懶漢模式初始化
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {//如果i位置沒有數(shù)據(jù)，就直接無鎖插入
            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)//如果在進(jìn)行擴(kuò)容，則先進(jìn)行擴(kuò)容操作
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            //如果以上條件都不滿足，那就要進(jìn)行加鎖操作，也就是存在hash沖突，鎖住鏈表或者紅黑樹的頭結(jié)點(diǎn)
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) { //表示該節(jié)點(diǎn)是鏈表結(jié)構(gòu)
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            //這里涉及到相同的key進(jìn)行put就會(huì)覆蓋原先的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;
                            if ((e = e.next) == null) {  //插入鏈表尾部
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) {//紅黑樹結(jié)構(gòu)
                        Node<K,V> p;
                        binCount = 2;
                        //紅黑樹結(jié)構(gòu)旋轉(zhuǎn)插入
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                       value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }
            if (binCount != 0) { //如果鏈表的長度大于8時(shí)就會(huì)進(jìn)行紅黑樹的轉(zhuǎn)換
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);//統(tǒng)計(jì)size，并且檢查是否需要擴(kuò)容
    return null;
}

private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {//空的table才能進(jìn)入初始化操作
        if ((sc = sizeCtl) < 0) //sizeCtl<0表示其他線程已經(jīng)在初始化了或者擴(kuò)容了，掛起當(dāng)前線程 
            Thread.yield(); // lost initialization race; just spin
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {//CAS操作SIZECTL為-1，表示初始化狀態(tài)
            try {
                if ((tab = table) == null || tab.length == 0) {
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    @SuppressWarnings("unchecked")
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];//初始化
                    table = tab = nt;
                    sc = n - (n >>> 2);//記錄下次擴(kuò)容的大小
                }
            } finally {
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

/**
 *幫助從舊的table的元素復(fù)制到新的table中
 */
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
    Node<K,V>[] nextTab; int sc;
    if (tab != null && (f instanceof ForwardingNode) &&
        (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) { //新的table nextTba已經(jīng)存在前提下才能幫助擴(kuò)容
        int rs = resizeStamp(tab.length);
        while (nextTab == nextTable && table == tab &&
               (sc = sizeCtl) < 0) {
            if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                sc == rs + MAX_RESIZERS || transferIndex <= 0)
                break;
            if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
                transfer(tab, nextTab);//調(diào)用擴(kuò)容方法
                break;
            }
        }
        return nextTab;
    }
    return table;
}

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    int n = tab.length, stride;
    // 將 length / 8 然后除以 CPU核心數(shù)。如果得到的結(jié)果小于 16，那么就使用 16。
    // 這里的目的是讓每個(gè) CPU 處理的桶一樣多，避免出現(xiàn)轉(zhuǎn)移任務(wù)不均勻的現(xiàn)象，如果桶較少的話，默認(rèn)一個(gè) CPU（一個(gè)線程）處理 16 個(gè)桶
    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
        stride = MIN_TRANSFER_STRIDE; // stride 一步的距離
    // 新的 table 尚未初始化
    if (nextTab == null) {            // initiating
        try {
            //構(gòu)建一個(gè)nextTable對(duì)象，其容量為原來容量的兩倍
            Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];        
            nextTab = nt;
        } catch (Throwable ex) {      // try to cope with OOME
            // 擴(kuò)容失敗， sizeCtl 使用 int 最大值。
            sizeCtl = Integer.MAX_VALUE;
            return;
        }
        // 更新成員變量
        nextTable = nextTab;
        // 更新轉(zhuǎn)移下標(biāo)，就是 老的 tab 的 length
        transferIndex = n;
    }
    // 新 tab 的 length
    int nextn = nextTab.length;
    // 創(chuàng)建一個(gè) fwd 節(jié)點(diǎn)，用于占位。當(dāng)別的線程發(fā)現(xiàn)這個(gè)槽位中是 fwd 類型的節(jié)點(diǎn)，則跳過這個(gè)節(jié)點(diǎn)。
    ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
    // 當(dāng)advance == true時(shí)，表明該節(jié)點(diǎn)已經(jīng)處理過了
    boolean advance = true;
    // 完成狀態(tài)，如果是 true，就結(jié)束此方法。
    boolean finishing = false; // to ensure sweep before committing nextTab
    // 死循環(huán),i 表示下標(biāo)，bound 表示當(dāng)前線程可以處理的當(dāng)前桶區(qū)間最小下標(biāo)
    for (int i = 0, bound = 0;;) {
        Node<K,V> f; int fh;
        // 控制 --i ,遍歷原h(huán)ash表中的節(jié)點(diǎn)
        while (advance) {
            int nextIndex, nextBound;
            // 對(duì) i 減一，判斷是否大于等于 bound （正常情況下，如果大于 bound 不成立，說明該線程上次領(lǐng)取的任務(wù)已經(jīng)完成了。那么，需要在下面繼續(xù)領(lǐng)取任務(wù)）
            // 如果對(duì) i 減一大于等于 bound（還需要繼續(xù)做任務(wù)），或者完成了，修改推進(jìn)狀態(tài)為 false，不能推進(jìn)了。任務(wù)成功后修改推進(jìn)狀態(tài)為 true。
            // 通常，第一次進(jìn)入循環(huán)，i-- 這個(gè)判斷會(huì)無法通過，從而走下面的 nextIndex 賦值操作（獲取最新的轉(zhuǎn)移下標(biāo)）。其余情況都是：如果可以推進(jìn)，將 i 減一，然后修改成不可推進(jìn)。如果 i 對(duì)應(yīng)的桶處理成功了，改成可以推進(jìn)。
            if (--i >= bound || finishing)
                advance = false; // 這里設(shè)置 false，是為了防止在沒有成功處理一個(gè)桶的情況下卻進(jìn)行了推進(jìn)
            // 這里的目的是：1. 當(dāng)一個(gè)線程進(jìn)入時(shí)，會(huì)選取最新的轉(zhuǎn)移下標(biāo)。2. 當(dāng)一個(gè)線程處理完自己的區(qū)間時(shí)，如果還有剩余區(qū)間的沒有別的線程處理。再次獲取區(qū)間。
            else if ((nextIndex = transferIndex) <= 0) {
                // 如果小于等于0，說明沒有區(qū)間了 ，i 改成 -1，推進(jìn)狀態(tài)變成 false，不再推進(jìn)，表示，擴(kuò)容結(jié)束了，當(dāng)前線程可以退出了
                // 這個(gè) -1 會(huì)在下面的 if 塊里判斷，從而進(jìn)入完成狀態(tài)判斷
                i = -1;
                advance = false;
            }
            // CAS 修改 transferIndex，即 length - 區(qū)間值，留下剩余的區(qū)間值供后面的線程使用
            else if (U.compareAndSwapInt
                    (this, TRANSFERINDEX, nextIndex,
                            nextBound = (nextIndex > stride ?
                                    nextIndex - stride : 0))) {
                bound = nextBound; // 這個(gè)值就是當(dāng)前線程可以處理的最小當(dāng)前區(qū)間最小下標(biāo)
                i = nextIndex - 1;  // 初次對(duì)i 賦值，這個(gè)就是當(dāng)前線程可以處理的當(dāng)前區(qū)間的最大下標(biāo)
                advance = false;
            }
        }
        if (i < 0 || i >= n || i + n >= nextn) {
            int sc;
            // 已經(jīng)完成所有節(jié)點(diǎn)復(fù)制了
            if (finishing) {
                nextTable = null;
                table = nextTab;        // table 指向nextTable
                sizeCtl = (n << 1) - (n >>> 1);     // sizeCtl閾值為原來的1.5倍
                return;     // 跳出死循環(huán)，
            }
            // CAS 更擴(kuò)容閾值，在這里面sizectl值減一，說明新加入一個(gè)線程參與到擴(kuò)容操作
            if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                    return;
                finishing = advance = true;
                i = n; // recheck before commit
            }
        }
        // 遍歷的節(jié)點(diǎn)為null，則放入到ForwardingNode 指針節(jié)點(diǎn)
        else if ((f = tabAt(tab, i)) == null)
            advance = casTabAt(tab, i, null, fwd);
        // f.hash == -1 表示遍歷到了ForwardingNode節(jié)點(diǎn)，意味著該節(jié)點(diǎn)已經(jīng)處理過了
        // 這里是控制并發(fā)擴(kuò)容的核心
        else if ((fh = f.hash) == MOVED)
            advance = true; // already processed
        else {
            // 節(jié)點(diǎn)加鎖
            synchronized (f) {
                // 節(jié)點(diǎn)復(fù)制工作
                if (tabAt(tab, i) == f) {
                    Node<K,V> ln, hn;
                    // fh >= 0 ,表示為鏈表節(jié)點(diǎn)
                    if (fh >= 0) {
                        // 構(gòu)造兩個(gè)鏈表  一個(gè)是原鏈表  另一個(gè)是原鏈表的反序排列
                        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);
                        }
                        // 在nextTable i 位置處插上鏈表
                        setTabAt(nextTab, i, ln);
                        // 在nextTable i + n 位置處插上鏈表
                        setTabAt(nextTab, i + n, hn);
                        // 在table i 位置處插上ForwardingNode 表示該節(jié)點(diǎn)已經(jīng)處理過了
                        setTabAt(tab, i, fwd);
                        // advance = true 可以執(zhí)行--i動(dòng)作，遍歷節(jié)點(diǎn)
                        advance = true;
                    }
                    // 如果是TreeBin，則按照紅黑樹進(jìn)行處理，處理邏輯與上面一致
                    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;
                            }
                        }
                        // 擴(kuò)容后樹節(jié)點(diǎn)個(gè)數(shù)若<=6，將樹轉(zhuǎn)鏈表
                        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;
                    }
                }
            }
        }
    }
}

private final void treeifyBin(Node<K,V>[] tab, int index) {
    Node<K,V> b; int n, sc;
    if (tab != null) {
        //如果整個(gè)table的數(shù)量小于64，就擴(kuò)容至原來的一倍，不轉(zhuǎn)紅黑樹了
        //因?yàn)檫@個(gè)閾值擴(kuò)容可以減少hash沖突，不必要去轉(zhuǎn)紅黑樹
        if ((n = tab.length) < MIN_TREEIFY_CAPACITY) 
            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
                        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;
                    }
                    //通過TreeBin對(duì)象對(duì)TreeNode轉(zhuǎn)換成紅黑樹
                    setTabAt(tab, index, new TreeBin<K,V>(hd));
                }
            }
        }
    }
}

private final void addCount(long x, int check) {
    CounterCell[] as; long b, s;
    //更新baseCount，table的數(shù)量，counterCells表示元素個(gè)數(shù)的變化
    if ((as = counterCells) != null ||
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
        CounterCell a; long v; int m;
        boolean uncontended = true;
        //如果多個(gè)線程都在執(zhí)行，則CAS失敗，執(zhí)行fullAddCount，全部加入count
        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)
            return;
        s = sumCount();
    }
     //check>=0表示需要進(jìn)行擴(kuò)容操作
    if (check >= 0) {
        Node<K,V>[] tab, nt; int n, sc;
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
               (n = tab.length) < MAXIMUM_CAPACITY) {
            int rs = resizeStamp(n);
            if (sc < 0) {
                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);
            }
            //當(dāng)前線程發(fā)起庫哦哦讓操作，nextTable=null
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
            s = sumCount();
        }
    }
}

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    int h = spread(key.hashCode()); //計(jì)算兩次hash
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {//讀取首節(jié)點(diǎn)的Node元素
        if ((eh = e.hash) == h) { //如果該節(jié)點(diǎn)就是首節(jié)點(diǎn)就返回
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        //hash值為負(fù)值表示正在擴(kuò)容，這個(gè)時(shí)候查的是ForwardingNode的find方法來定位到nextTable來
        //查找，查找到就返回
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        while ((e = e.next) != null) {//既不是首節(jié)點(diǎn)也不是ForwardingNode，那就往下遍歷
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

public int size() {
    long n = sumCount();
    return ((n < 0L) ? 0 :
            (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
            (int)n);
}
final long sumCount() {
    CounterCell[] as = counterCells; CounterCell a; //變化的數(shù)量
    long sum = baseCount;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}