/** 數(shù)組最大容量大小(1073741824) */
private static final int MAXIMUM_CAPACITY = 1 << 30;
/** 默認(rèn)的初始容量大小 */
private static final int DEFAULT_CAPACITY = 16;
/** 默認(rèn)的并發(fā)等級 */
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
/** 負(fù)載因子 */
private static final float LOAD_FACTOR = 0.75f;
/** 鏈表轉(zhuǎn)換為紅黑樹的閾值 */
static final int TREEIFY_THRESHOLD = 8;
/** 紅黑樹轉(zhuǎn)換為鏈表的閾值 */
static final int UNTREEIFY_THRESHOLD = 6;
/**
 * 最小樹化閾值
 * 當(dāng)鏈表中的節(jié)點數(shù)量大于等于8時,如果數(shù)組的長度小于最小樹化閾值則不會將鏈表轉(zhuǎn)換為紅黑樹,而是對數(shù)組進(jìn)行擴(kuò)容
 * 將鏈表中的節(jié)點分散到別的索引節(jié)點中去,只有當(dāng)數(shù)組的長度大于等于最小樹化閾值則會將鏈表轉(zhuǎn)換為紅黑樹
 */
static final int MIN_TREEIFY_CAPACITY = 64;
/** 擴(kuò)容時,每個cpu最少需要負(fù)責(zé)的區(qū)域長度 */
private static final int MIN_TRANSFER_STRIDE = 16;
/** 擴(kuò)容時生成標(biāo)記的二進(jìn)制所在位置 */
private static int RESIZE_STAMP_BITS = 16;
/** 擴(kuò)容時記錄擴(kuò)容容量的標(biāo)記的二進(jìn)制所在位置 */
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
//節(jié)點正在移動
static final int MOVED = -1;
//節(jié)點已被樹化
static final int TREEBIN = -2;
static final int RESERVED = -3; // hash for transient reservations
//32位二進(jìn)制中正數(shù)最大的值,主要用于對key的hash值進(jìn)行二次運(yùn)算
static final int HASH_BITS = 0x7fffffff;
/** 當(dāng)前機(jī)器的cpu數(shù)量 */
static final int NCPU = Runtime.getRuntime().availableProcessors();
/**
 * 存放元素的數(shù)組對象
 * 只有在第一次添加元素的時候進(jìn)行初始化
 * 如果沒有指定數(shù)組容量則使用默認(rèn)的容量16進(jìn)行初始化
 * 數(shù)組容量為2的次方,如果指定的數(shù)組容量不是2的次方則會進(jìn)行計算獲取到大于指定容量并是2的次方的數(shù)
 */
transient volatile Node<K, V>[] table;
/** 擴(kuò)容后的新數(shù)組,如果該數(shù)組不為空則說明當(dāng)前有其它線程正在進(jìn)行擴(kuò)容 */
private transient volatile Node<K, V>[] nextTable;
/** 基本計數(shù)器值,在沒有線程爭用的時候才會使用 */
private transient volatile long baseCount;
/**
 * -1時則說明數(shù)組對象正在初始化
 * 如果數(shù)組未被初始化時該值為數(shù)組初始化時的大小
 * 如果數(shù)組已被初始化該值為數(shù)組擴(kuò)容的閾值
 * -N:低16位二進(jìn)制轉(zhuǎn)換為十進(jìn)制數(shù)M,M-1則是當(dāng)前正在擴(kuò)容的線程數(shù)量
 */
private transient volatile int sizeCtl;
/**
 * 擴(kuò)容時需要轉(zhuǎn)移舊數(shù)組中的剩余的索引位置長度
 * 每個線程最少負(fù)責(zé)16個索引位置上的節(jié)點轉(zhuǎn)移
 */
private transient volatile int transferIndex;
/**
 * 計數(shù)器數(shù)組的鎖標(biāo)識
 * 用與初始化計數(shù)器數(shù)組以及擴(kuò)容和創(chuàng)建計數(shù)器對象的時候使用
 */
private transient volatile int cellsBusy;
/** 計數(shù)器數(shù)組 */
private transient volatile CounterCell[] counterCells;

/**
 * 創(chuàng)建一個默認(rèn)容量為16的數(shù)組對象
 * 該構(gòu)造方法中并沒有執(zhí)行任何操作
 * 并沒有創(chuàng)建默認(rèn)容量的數(shù)組對象
 * 只有在第一次添加元素的時候才會初始化數(shù)組對象
 */
public ConcurrentHashMap() {
}
/**
 * 創(chuàng)建一個指定初始容量的數(shù)組對象
 * @param initialCapacity 指定的初始容量
 */
public ConcurrentHashMap(int initialCapacity) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException();
    //校驗指定的初始容量大小是否大于等于最大容量大小的一半
    //如果大于等于最大容量大小的一半則在后續(xù)第一次添加元素的時候使用最大容量大小創(chuàng)建數(shù)組
    //如果小于最大容量大小的一半則根據(jù)指定容量來計算最接近指定容量大小并大于指定容量的2的次方
    //此處有一個疑問,指定容量大小如果等于最大容量大小的一半則說明指定容量大小是2的29次方,為什么不使用指定容量大小,而是使用最大的容量大小?
    //從tableSizeFor方法也能看出,如果指定的初始容量大小本來就是2的次方的話并不會使用指定的初始容量大小來創(chuàng)建數(shù)組對象
    //而是使用大于指定初始容量大小的2的次方來創(chuàng)建數(shù)組對象,比如指定的初始容量大小為16,那就會使用32來創(chuàng)建數(shù)組對象
    //在HashMap中如果指定的初始容量大小本來就是2的次方的話則會使用指定的初始容量大小來創(chuàng)建數(shù)組對象
    //并不會像ConcurrentHashMap一樣會取比當(dāng)前指定的2的次方的初始容量大小大的2的次方的容量大小來創(chuàng)建數(shù)組對象
    int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
            MAXIMUM_CAPACITY : tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
    //將計算后的容量大小賦值給sizeCtl等待初始化
    this.sizeCtl = cap;
}
/**
 * 根據(jù)指定的集合中的元素來創(chuàng)建新的數(shù)組對象
 * @param m the map
 */
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
    //使用默認(rèn)的初始容量大小等待初始化
    this.sizeCtl = DEFAULT_CAPACITY;
    //初始化新的數(shù)組對象并將指定集合中的元素添加到新的數(shù)組對象中
    putAll(m);
}
/**
 * 根據(jù)指定的初始容量大小和指定的負(fù)載因子來創(chuàng)建新的數(shù)組對象
 */
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
    this(initialCapacity, loadFactor, 1);
}
/**
 * 根據(jù)指定的初始容量大小和指定的負(fù)載因子和并發(fā)數(shù)來創(chuàng)建新的數(shù)組對象
 */
public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    if (initialCapacity < concurrencyLevel)
        //初始容量大小小于并發(fā)數(shù)則使用并發(fā)數(shù)來創(chuàng)建數(shù)組對象
        initialCapacity = concurrencyLevel;
    //通過計算獲取到擴(kuò)容的閾值
    long size = (long) (1.0 + (long) initialCapacity / loadFactor);
    //如果閾值大于等于最大容量大小則使用最大容量大小來創(chuàng)建新的數(shù)組對象
    //如果閾值小于最大容量大小則使用閾值來計算獲取到大于閾值并是2的次方的值
    //使用計算后的值來創(chuàng)建新的數(shù)組對象
    int cap = (size >= (long) MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : tableSizeFor((int) size);
    //將計算后的容量大小賦值給sizeCtl等待初始化
    this.sizeCtl = cap;
}

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)
        //key和value不能為空
        throw new NullPointerException();
    //將key的hash值的高16位二進(jìn)制參加運(yùn)算獲取到新的hash值
    int hash = spread(key.hashCode());
    //指定索引位置上節(jié)點的數(shù)量
    int binCount = 0;
    for (Node<K, V>[] tab = table; ; ) {
        //數(shù)組中指定索引的節(jié)點
        Node<K, V> f;
        //n 數(shù)組長度
        //i key所在的數(shù)組索引位置
        //fh 指定索引的節(jié)點的hash值
        int n, i, fh;
        //校驗數(shù)組是否已經(jīng)初始化
        if (tab == null || (n = tab.length) == 0)
            //數(shù)組未初始化則初始化數(shù)組
            //并返回初始化完成的數(shù)組對象
            tab = initTable();
        //通過數(shù)組索引長度與key的hash值進(jìn)行與運(yùn)算獲取到指定索引位置上的元素節(jié)點,并校驗元素節(jié)點是否為空
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            //指定索引位置上的節(jié)點不存在則使用傳遞進(jìn)來的key和value創(chuàng)建新的節(jié)點
            //并將新的節(jié)點放置到指定索引位置上
            if (casTabAt(tab, i, null,new Node<K, V>(hash, key, value, null)))
                //節(jié)點添加成功則退出循環(huán)
                break;
        //校驗索引位置上的節(jié)點是否正在移動
        } else if ((fh = f.hash) == MOVED)
            //如果索引位置上的節(jié)點正在移動則幫忙移動節(jié)點到新的數(shù)組中
            //協(xié)助擴(kuò)容
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            //使用鎖鎖住指定索引位置上的節(jié)點
            //這樣其它線程就不能對該索引位置上的節(jié)點進(jìn)行操作
            //其它線程可以對其它索引位置上的節(jié)點進(jìn)行操作
            synchronized (f) {
                //校驗指定索引位置上的節(jié)點是否被更改
                if (tabAt(tab, i) == f) {
                    //校驗節(jié)點的hash值是否大于等于0
                    //如果節(jié)點的hash值大于等于0則說明該索引位置上只有一個節(jié)點或節(jié)點是一個鏈表節(jié)點
                    if (fh >= 0) {
                        binCount = 1;
                        //從指定索引位置上的節(jié)點開始遍歷
                        for (Node<K, V> e = f; ; ++binCount) {
                            K ek;
                            //校驗遍歷到的節(jié)點的hash值以及key是否與傳遞的key和計算的hash值相同
                            //如果相同則根據(jù)onlyIfAbsent參數(shù)來決定是否需要使用新的value替換舊的value
                            if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) {
                                //獲取舊的value
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    //使用新的value替換舊的value
                                    e.val = value;
                                break;
                            }
                            //遍歷到的節(jié)點的hash值以及key不相同
                            //則判斷當(dāng)前遍歷到的節(jié)點是否是鏈表上的最后一個節(jié)點
                            //如果不是最后一個節(jié)點則繼續(xù)遍歷
                            //如果是最后一個節(jié)點則為key和value創(chuàng)建一個新的節(jié)點
                            //并將原尾節(jié)點的next指針指向新創(chuàng)建的節(jié)點
                            Node<K, V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K, V>(hash, key, value, null);
                                break;
                            }
                        }
                     //校驗節(jié)點是否是一個紅黑樹節(jié)點
                    } else if (f instanceof TreeBin) {
                        Node<K, V> p;
                        binCount = 2;
                        //將指定的key和value封裝成一個樹節(jié)點并添加到紅黑樹中
                        //如果紅黑樹中已經(jīng)存在相同key的節(jié)點則根據(jù)onlyIfAbsent參數(shù)來決定是否使用新的value替換紅黑樹中的節(jié)點的value
                        if ((p = ((TreeBin<K, V>) f).putTreeVal(hash, key,value)) != null) {
                            //獲取節(jié)點中的舊值
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                //替換節(jié)點中的value
                                p.val = value;
                        }
                    }
                }
            }
            if (binCount != 0) {
                //校驗索引位置上的節(jié)點的數(shù)量是否到達(dá)樹化的閾值
                //如果該索引位置上的節(jié)點本來就是樹節(jié)點則不會繼續(xù)樹化
                //只有當(dāng)索引位置上的節(jié)點是鏈表節(jié)點并且節(jié)點的數(shù)量大于等于8的時候才會樹化
                if (binCount >= TREEIFY_THRESHOLD)
                    //索引位置上的節(jié)點數(shù)量已經(jīng)到達(dá)樹化的閾值
                    //則將該索引位置上的所有節(jié)點轉(zhuǎn)換為樹節(jié)點
                    treeifyBin(tab, i);
                if (oldVal != null)
                    //返回被替換的舊值
                    return oldVal;
                break;
            }
        }
    }
    //更新集合中元素節(jié)點的數(shù)量,并校驗是否需要擴(kuò)容
    addCount(1L, binCount);
    return null;
}

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

private final Node<K, V>[] initTable() {
    Node<K, V>[] tab;
    int sc;
    //校驗數(shù)組是否未被初始化
    while ((tab = table) == null || tab.length == 0) {
        if ((sc = sizeCtl) < 0)
            //數(shù)組長度小于0則說明其它線程正在準(zhǔn)備初始化數(shù)組
            //當(dāng)前線程則需要讓出cpu讓其它線程初始化數(shù)組
            Thread.yield();
        //通過cas操作將sizeCtl修改成-1,告知其它線程當(dāng)前線程正在準(zhǔn)備初始化數(shù)組
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                if ((tab = table) == null || tab.length == 0) {
                    //如果指定了初始容量則使用指定的初始容量來創(chuàng)建數(shù)組
                    //如果沒有指定則使用默認(rèn)的初始容量大小16來創(chuàng)建數(shù)組
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    //初始化數(shù)組
                    @SuppressWarnings("unchecked")
                    Node<K, V>[] nt = (Node<K, V>[]) new Node<?, ?>[n];
                    //將初始化的數(shù)組對象賦值給當(dāng)前集合中的數(shù)組對象
                    //并賦值給tab,下一次循環(huán)校驗則會發(fā)現(xiàn)tab不為空則會退出循環(huán)并退出當(dāng)前方法
                    table = tab = nt;
                    //計算數(shù)組擴(kuò)容的閾值
                    sc = n - (n >>> 2);
                }
            } finally {
                //如果try中的代碼塊執(zhí)行失敗時sizeCtl則是原先數(shù)組的長度
                //執(zhí)行成功時sizeCtl則是擴(kuò)容的閾值
                sizeCtl = sc;
            }
            break;
        }
    }
    //數(shù)組已被初始化返回數(shù)組
    return tab;
}

static {
    try {
        U = sun.misc.Unsafe.getUnsafe();
        Class<?> k = ConcurrentHashMap.class;
        SIZECTL = U.objectFieldOffset
                (k.getDeclaredField("sizeCtl"));
        TRANSFERINDEX = U.objectFieldOffset
                (k.getDeclaredField("transferIndex"));
        BASECOUNT = U.objectFieldOffset
                (k.getDeclaredField("baseCount"));
        CELLSBUSY = U.objectFieldOffset
                (k.getDeclaredField("cellsBusy"));
        Class<?> ck = CounterCell.class;
        CELLVALUE = U.objectFieldOffset
                (ck.getDeclaredField("value"));
        Class<?> ak = Node[].class;
        //獲取數(shù)組中第一個元素在內(nèi)存中開始的偏移量
        ABASE = U.arrayBaseOffset(ak);
        //獲取數(shù)組中元素在內(nèi)存中的增量地址
        int scale = U.arrayIndexScale(ak);
        if ((scale & (scale - 1)) != 0)
            throw new Error("data type scale not a power of two");
        //獲取增量地址在32位二進(jìn)制情況下高位連續(xù)包含0的個數(shù)
        //使用31減去包含0的個數(shù)獲取到需要位移的次數(shù)
        ASHIFT = 31 - Integer.numberOfLeadingZeros(scale);
    } catch (Exception e) {
        throw new Error(e);
    }

static final <K, V> Node<K, V> tabAt(Node<K, V>[] tab, int i) {
    //根據(jù)指定的索引位置計算該索引中的節(jié)點在內(nèi)存中的偏移量
    //并從tab數(shù)組中根據(jù)索引所在的內(nèi)存的偏移量獲取節(jié)點
    return (Node<K, V>) U.getObjectVolatile(tab, ((long) i << ASHIFT) + ABASE);
}

static final <K, V> boolean casTabAt(Node<K, V>[] tab, int i,Node<K, V> c, Node<K, V> v) {
    //根據(jù)指定的索引位置計算該索引中的節(jié)點在內(nèi)存中的偏移量
    //并根據(jù)偏移量獲取節(jié)點,并將獲取到的節(jié)點與傳遞的節(jié)點c進(jìn)行比較
    //如果兩個節(jié)點相同則使用節(jié)點v進(jìn)行替換
    return U.compareAndSwapObject(tab, ((long) i << ASHIFT) + ABASE, c, v);
}

final Node<K, V>[] helpTransfer(Node<K, V>[] tab, Node<K, V> f) {
    Node<K, V>[] nextTab;
    int sc;
    //f instanceof ForwardingNode 當(dāng)前節(jié)點正在轉(zhuǎn)移
    //nextTab = ((ForwardingNode<K, V>) f).nextTable) != null 擴(kuò)容的新數(shù)組是否不為空
    //如果條件都為true則說明有線程正在擴(kuò)容中,當(dāng)前線程則需要協(xié)助擴(kuò)容
    if (tab != null && (f instanceof ForwardingNode) && (nextTab = ((ForwardingNode<K, V>) f).nextTable) != null) {
        //擴(kuò)容標(biāo)記
        int rs = resizeStamp(tab.length);
        while (nextTab == nextTable && table == tab && (sc = sizeCtl) < 0) {
            //(sc >>> RESIZE_STAMP_SHIFT) != rs 校驗擴(kuò)容標(biāo)識是否一致,不一致則說明不是同一個數(shù)組
            //sc == rs + 1 應(yīng)該是sc == (rs << 16) + 1 校驗擴(kuò)容是否完成
            //sc == rs + MAX_RESIZERS 應(yīng)該是sc == (rs << 16) + MAX_RESIZERS 校驗擴(kuò)容的線程的數(shù)量是否到達(dá)最大
            //transferIndex <= 0 舊數(shù)組中還有多少沒有轉(zhuǎn)移的索引節(jié)點長度,如果小于等于0則說明已經(jīng)轉(zhuǎn)移完成則不需要協(xié)助
            if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || sc == rs + MAX_RESIZERS || transferIndex <= 0)
                break;
            //擴(kuò)容線程加1
            if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
                //協(xié)助擴(kuò)容
                transfer(tab, nextTab);
                break;
            }
        }
        //擴(kuò)容完成則返回新的數(shù)組,對新的數(shù)組進(jìn)行操作
        return nextTab;
    }
    //當(dāng)前節(jié)點還未被轉(zhuǎn)移或新的數(shù)組還沒有被初始化則對舊數(shù)組進(jìn)行操作
    return table;
}

final TreeNode<K, V> putTreeVal(int h, K k, V v) {
    Class<?> kc = null;
    boolean searched = false;
    for (TreeNode<K, V> p = root; ; ) {
        int dir, ph;
        K pk;
        if (p == null) {
            first = root = new TreeNode<K, V>(h, k, v, null, null);
            break;
        } else if ((ph = p.hash) > h)
            dir = -1;
        else if (ph < h)
            dir = 1;
        else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
            return p;
        else if ((kc == null &&
                (kc = comparableClassFor(k)) == null) ||
                (dir = compareComparables(kc, k, pk)) == 0) {
            if (!searched) {
                TreeNode<K, V> q, ch;
                searched = true;
                if (((ch = p.left) != null &&
                        (q = ch.findTreeNode(h, k, kc)) != null) ||
                        ((ch = p.right) != null &&
                                (q = ch.findTreeNode(h, k, kc)) != null))
                    return q;
            }
            dir = tieBreakOrder(k, pk);
        }
        TreeNode<K, V> xp = p;
        if ((p = (dir <= 0) ? p.left : p.right) == null) {
            TreeNode<K, V> x, f = first;
            first = x = new TreeNode<K, V>(h, k, v, f, xp);
            if (f != null)
                //將新添加的樹節(jié)點設(shè)置為鏈表的頭節(jié)點
                f.prev = x;
            if (dir <= 0)
                xp.left = x;
            else
                xp.right = x;
            if (!xp.red)
                x.red = true;
            else {
                //獲取寫鎖,如果獲取寫鎖失敗則會將當(dāng)前線程掛起進(jìn)行等待
                //如果有線程正在讀,那當(dāng)前寫的線程就要掛起進(jìn)行等待
                //當(dāng)讀的線程執(zhí)行完成之后就會去喚醒掛起的線程
                //如果說當(dāng)前線程在寫,有線程準(zhǔn)備讀
                //那讀線程并不會去讀取紅黑樹中的節(jié)點
                //而是讀取鏈表的節(jié)點,因為TreeBin對象中包含了紅黑樹的根節(jié)點并且也包含了鏈表的頭節(jié)點
                //如果發(fā)生寫寫的問題呢?
                //其實并不會發(fā)生寫寫的問題,因為當(dāng)前整個方法都被外部的synchronized鎖住了
                lockRoot();
                try {
                    //平衡紅黑樹中的節(jié)點
                    root = balanceInsertion(root, x);
                } finally {
                    //釋放鎖
                    unlockRoot();
                }
            }
            break;
        }
    }
    assert checkInvariants(root);
    return null;
}

//鎖狀態(tài)
volatile int lockState;
//寫鎖
static final int WRITER = 1; // set while holding write lock
//等待
static final int WAITER = 2; // set when waiting for write lock
//讀鎖
static final int READER = 4; // increment value for setting read lock

private final void lockRoot() {
    //嘗試加寫鎖
    if (!U.compareAndSwapInt(this, LOCKSTATE, 0, WRITER))
        //加寫鎖失敗則嘗試將線程掛起進(jìn)行等待
        contendedLock();
}

private final void contendedLock() {
    boolean waiting = false;
    for (int s; ; ) {
        /**
         * ~WAITER = 1111 1111 1111 1111 1111 1111 1111 1101
         * ((s = lockState) & ~WAITER) == 0 等于0則說明當(dāng)前沒有線程對當(dāng)前TreeBin對象下的紅黑樹進(jìn)行加鎖
         * 不等于則說明有線程對TreeBin對象下的紅黑樹加鎖
         */
        if (((s = lockState) & ~WAITER) == 0) {
            //沒有線程對TreeBin對象下的紅黑樹加鎖
            //當(dāng)前線程則可以對TreeBin對象下的紅黑樹嘗試加鎖
            if (U.compareAndSwapInt(this, LOCKSTATE, s, WRITER)) {
                if (waiting)
                    //將等待線程清空
                    waiter = null;
                return;
            }
        //(s & WAITER) == 0 執(zhí)行當(dāng)前判斷語句的時候則說明有線程對紅黑樹加了鎖
        //如果(s & WAITER)等于0則說明沒有線程在等待加鎖
        //此時當(dāng)前線程就可以進(jìn)行等待
        } else if ((s & WAITER) == 0) {
            //將鎖狀態(tài)的32位二進(jìn)制中的第2位設(shè)置為1
            //代表當(dāng)前有一個線程正在等待加鎖
            if (U.compareAndSwapInt(this, LOCKSTATE, s, s | WAITER)) {
                waiting = true;
                //將TreeBin中的等待線程設(shè)置為當(dāng)前線程
                waiter = Thread.currentThread();
            }
        } else if (waiting)
            //當(dāng)前線程已經(jīng)設(shè)置成了等待狀態(tài)了,此時就需要將線程掛起
            LockSupport.park(this);
    }
}

if (binCount != 0) {
    //校驗索引位置上的節(jié)點的數(shù)量是否到達(dá)樹化的閾值
    //如果該索引位置上的節(jié)點本來就是樹節(jié)點則不會繼續(xù)樹化
    //只有當(dāng)索引位置上的節(jié)點是鏈表節(jié)點并且節(jié)點的數(shù)量大于等于8的時候才會樹化
    if (binCount >= TREEIFY_THRESHOLD)
        //索引位置上的節(jié)點數(shù)量已經(jīng)到達(dá)樹化的閾值
        //則將該索引位置上的所有節(jié)點轉(zhuǎn)換為樹節(jié)點
        treeifyBin(tab, i);
    if (oldVal != null)
        //返回被替換的舊值
        return oldVal;
    break;
}

private final void treeifyBin(Node<K, V>[] tab, int index) {
    //指定索引位置上的節(jié)點
    Node<K, V> b;
    //n 數(shù)組長度
    int n, sc;
    if (tab != null) {
        //校驗數(shù)組的長度是否小于最小的樹化閾值
        if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
            /**
             * 數(shù)組長度小于最小的樹化閾值
             * 此時并不會將數(shù)組中的鏈表節(jié)點轉(zhuǎn)換為樹節(jié)點
             * 只會將數(shù)組進(jìn)行擴(kuò)容
             *
             * 如果仔細(xì)查看tryPresize方法你會發(fā)現(xiàn)該方法中也對n進(jìn)行了左移1位
             * 當(dāng)前tryPresize傳參的時候就已經(jīng)對n進(jìn)行了左移1位,然后在方法里面又對n進(jìn)行了左移1位
             * 這樣是不是就對數(shù)組進(jìn)行了4倍擴(kuò)容,并不是我們想的那樣2倍擴(kuò)容呢?
             * 其實不是的,在tryPresize方法里面并沒有使用2次位移后的n來擴(kuò)容
             * 而是使用最開始的數(shù)組長度n來計算進(jìn)行擴(kuò)容
             */
            tryPresize(n << 1);
            //獲取指定索引位置上的元素節(jié)點并校驗元素節(jié)點是否不為空
            //如果元素節(jié)點不為空則校驗該節(jié)點的hash值是大于等于0
            //如果hash值大于等于0則說明該節(jié)點需要轉(zhuǎn)換為樹節(jié)點
            //如果hash值小于0則說明該節(jié)點正在移動或已經(jīng)被樹化了
        else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
            //使用鎖鎖住指定索引位置上的節(jié)點
            //在添加元素的時候也會對指定索引位置上的節(jié)點加鎖
            //如果兩個索引位置都是相同的索引位置的時候,如果添加元素的線程先加了鎖
            //那執(zhí)行到當(dāng)前方法的線程則會等待添加元素的線程釋放鎖
            //當(dāng)添加元素的線程釋放了鎖之后,當(dāng)前方法的線程則會獲取鎖將索引位置上所有的節(jié)點都樹化,包括新添加的元素節(jié)點
            //如果是執(zhí)行到當(dāng)前方法的線程獲取到了鎖,那添加元素的線程則會等待
            //當(dāng)指定索引位置上的所有節(jié)點都樹化了之后并釋放了鎖
            //添加元素的線程則會去獲取鎖,此時添加元素的線程會發(fā)現(xiàn)當(dāng)前索引位置上的節(jié)點已經(jīng)是樹節(jié)點
            //則會將元素節(jié)點添加到紅黑樹中并使紅黑樹平衡
            synchronized (b) {
                //校驗在獲取鎖的時候指定索引位置上的節(jié)點是否被更改
                if (tabAt(tab, index) == b) {
                    //hd 頭節(jié)點
                    //tl 當(dāng)前遍歷到的節(jié)點的上一個節(jié)點
                    TreeNode<K, V> hd = null, tl = null;
                    //從指定索引位置上的節(jié)點開始遍歷,依次將鏈表上的所有節(jié)點轉(zhuǎn)換為樹節(jié)點
                    for (Node<K, V> e = b; e != null; e = e.next) {
                        //將普通節(jié)點轉(zhuǎn)換為樹節(jié)點
                        TreeNode<K, V> p = new TreeNode<K, V>(e.hash, e.key, e.val, null, null);
                        //校驗當(dāng)前遍歷的節(jié)點是否是鏈表中的頭節(jié)點
                        //如果是頭節(jié)點則將該節(jié)點設(shè)置為了樹節(jié)點的頭節(jié)點
                        //如果不是頭節(jié)點則將當(dāng)前轉(zhuǎn)換的樹節(jié)點與上一個樹節(jié)點進(jìn)行關(guān)聯(lián)
                        if ((p.prev = tl) == null)
                            hd = p;
                        else
                            tl.next = p;
                        tl = p;
                    }
                    //創(chuàng)建一個TreeBin對象并將樹化的節(jié)點轉(zhuǎn)換為紅黑樹
                    //TreeBin對象中保留著紅黑樹的根節(jié)點以及鏈表的頭節(jié)點
                    //再調(diào)用setTabAt方法將TreeBin對象添加到指定的索引位置上
                    //在HashMap中并沒有創(chuàng)建一個TreeBin對象來存放紅黑樹的根節(jié)點
                    //而是直接將紅黑樹的根節(jié)點放置到指定的索引位置上
                    setTabAt(tab, index, new TreeBin<K, V>(hd));
                }
            }
        }
    }
}

TreeBin(TreeNode<K, V> b) {
    //給當(dāng)前TreeBin對象設(shè)置一個樹化標(biāo)識
    super(TREEBIN, null, null, null);
    //樹化的頭節(jié)點的設(shè)置為鏈表的頭節(jié)點
    this.first = b;
    //根節(jié)點
    TreeNode<K, V> r = null;
    //從樹化的頭節(jié)點開始遍歷將節(jié)點轉(zhuǎn)換為紅黑樹中的節(jié)點,直到?jīng)]有下一個節(jié)點
    for (TreeNode<K, V> x = b, next; x != null; x = next) {
        //下一個節(jié)點
        next = (TreeNode<K, V>) x.next;
        //初始化每個樹節(jié)點的左右子節(jié)點
        x.left = x.right = null;
        if (r == null) {
            //根節(jié)點為空則將當(dāng)前遍歷到的節(jié)點設(shè)置為根節(jié)點
            //并將該節(jié)點的顏色設(shè)置為黑色
            x.parent = null;
            x.red = false;
            r = x;
        } else {
            //待添加到紅黑樹中的節(jié)點的key
            K k = x.key;
            //待添加到紅黑樹中的節(jié)點的hash值
            int h = x.hash;
            Class<?> kc = null;
            //從紅黑樹的根節(jié)點開始遍歷來校驗節(jié)點放置的位置
            for (TreeNode<K, V> p = r; ; ) {
                //dir 節(jié)點添加到紅黑樹中的位置
                //ph 被遍歷到的紅黑樹中的節(jié)點的key
                int dir, ph;
                //被遍歷到的紅黑樹中的節(jié)點的key
                K pk = p.key;
                if ((ph = p.hash) > h)
                    //被遍歷到的紅黑樹中的節(jié)點的hash值大于待添加到紅黑樹中的節(jié)點的hash值
                    //則需要將節(jié)點添加到紅黑樹中的左子節(jié)點
                    dir = -1;
                else if (ph < h)
                    //被遍歷到的紅黑樹中的節(jié)點的hash值小于待添加到紅黑樹中的節(jié)點的hash值
                    //則需要將節(jié)點添加到紅黑樹中的右子節(jié)點
                    dir = 1;
                else if ((kc == null && (kc = comparableClassFor(k)) == null) || (dir = compareComparables(kc, k, pk)) == 0)
                    dir = tieBreakOrder(k, pk);
                TreeNode<K, V> xp = p;
                //校驗待添加到紅黑樹中的節(jié)點所放置的位置是否有節(jié)點存在
                //如果有節(jié)點存在則重新走循環(huán)與子節(jié)點繼續(xù)比較直到?jīng)]有了子節(jié)點
                if ((p = (dir <= 0) ? p.left : p.right) == null) {
                    //放置待添加到紅黑樹中的節(jié)點的位置沒有了節(jié)點
                    //則會將節(jié)點添加到紅黑樹中
                    //將待添加節(jié)點的父節(jié)點的指針指向當(dāng)前遍歷到的紅黑樹中的節(jié)點
                    x.parent = xp;
                    if (dir <= 0)
                        //將待添加的節(jié)點放置到被遍歷到的節(jié)點的左子節(jié)點
                        xp.left = x;
                    else
                        //將待添加的節(jié)點放置到被遍歷到的節(jié)點的右子節(jié)點
                        xp.right = x;
                    //紅黑樹中添加了新的節(jié)點,可能讓紅黑樹不在平衡
                    //所以需要將紅黑樹中的節(jié)點進(jìn)行平衡
                    r = balanceInsertion(r, x);
                    break;
                }
            }
        }
    }
    //TreeBin對象記錄根節(jié)點
    this.root = r;
    assert checkInvariants(root);
}

/**
 * 添加元素節(jié)點或刪除元素節(jié)點的時候需要將計數(shù)器中的值修改
 * 如果在單線程的情況下直接對基本計數(shù)器值修改
 * 如果在多線程的情況下對基本計數(shù)器修改失敗的話并且計數(shù)器數(shù)組為空
 * 則需要初始化計數(shù)器數(shù)組,并使用線程生成隨機(jī)數(shù)與計數(shù)器數(shù)組的長度進(jìn)行運(yùn)算獲取到指定的索引位置
 * 并將指定索引位置上的計數(shù)器對象進(jìn)行初始化并將check值保存在計數(shù)器對象中的value
 * 如果計數(shù)器數(shù)組不為空,但是指定的索引位置上的計數(shù)器對象為空
 * 則初始化計數(shù)器對象并將check值保存在計數(shù)器對象中的value
 * 如果計數(shù)器對象也不為空則直接將check值累加到計數(shù)器對象中的value
 * 在將check值保存之后則會校驗當(dāng)前集合中的數(shù)組是否需要擴(kuò)容
 * 如果需要擴(kuò)容則會調(diào)用transfer方法來進(jìn)行擴(kuò)容
 */
private final void addCount(long x, int check) {
    //計數(shù)器數(shù)組
    CounterCell[] as;
    //b 基本計數(shù)器值
    long b, s;
    //計數(shù)器數(shù)組counterCells不為空則說明之前已經(jīng)發(fā)生過多線程對基本計數(shù)器baseCount進(jìn)行操作
    //計數(shù)器數(shù)組counterCells為空則說明之前一直在單線程的情況下對基本計數(shù)器baseCount進(jìn)行操作
    //如果計數(shù)器數(shù)組為空則會嘗試對基本計數(shù)器baseCount進(jìn)行操作,如果對baseCount操作失敗則說明當(dāng)前處于多線程的情況下
    //此時就需要初始化counterCells
    if ((as = counterCells) != null || !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
        CounterCell a;
        long v;
        int m;
        boolean uncontended = true;
        //as == null || (m = as.length - 1) < 0 校驗計數(shù)器數(shù)組是否初始化,如果沒有初始化則調(diào)用fullAddCount方法進(jìn)行初始化
        //(a = as[ThreadLocalRandom.getProbe() & m]) == null 當(dāng)前計數(shù)器數(shù)組不為空的時候則使用線程生成的隨機(jī)數(shù)
        //與計數(shù)器數(shù)組的長度進(jìn)行與運(yùn)算獲取到指定索引位置上的計數(shù)器對象,并校驗計數(shù)器對象是否為空
        //如果計數(shù)器對象為空則調(diào)用fullAddCount方法對指定索引位置上的計數(shù)器對象進(jìn)行初始化
        //!(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x)) 計數(shù)器數(shù)組不為空并且運(yùn)算獲取到的指定索引位置上的計數(shù)器對象也不為空
        //此時就可以對計數(shù)器對象進(jìn)行操作,如果操作失敗則說明有其它線程獲取到了這個索引位置上的計數(shù)器對象并對這個計數(shù)器進(jìn)行操作中
        //此時就需要調(diào)用fullAddCount方法選擇其它索引位置上的計數(shù)器對象進(jìn)行操作
        if (as == null || (m = as.length - 1) < 0 || (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
                !(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
            //對計數(shù)器數(shù)組以及計數(shù)器數(shù)組中的計數(shù)器對象進(jìn)行初始化
            //一個線程對計數(shù)器對象操作失敗則會更換其它索引上的計數(shù)器對象進(jìn)行操作
            //如果這個線程多次對計數(shù)器對象操作失敗并且當(dāng)前計數(shù)器數(shù)組的長度小于cpu的數(shù)量
            //此時就會嘗試進(jìn)行擴(kuò)容,然后對擴(kuò)容之后的數(shù)組中的計數(shù)器對象進(jìn)行操作
            //如果說計數(shù)器數(shù)組的長度不小于cpu的數(shù)量則不會進(jìn)行擴(kuò)容
            //只會一直更換計數(shù)器對象進(jìn)行操作,直到操作成功
            fullAddCount(x, uncontended);
            return;
        }
        //校驗check是否小于等于1
        //check=-1的情況下則說明刪除了指定索引位置上的元素節(jié)點
        //check=0的情況下則說明指定索引位置上沒有元素節(jié)點,直接將指定的key和value封裝成一個節(jié)點放置到指定的索引位置上
        //check=1的情況在put方法下則說明指定索引位置上有元素節(jié)點,但是只是對索引位置上的元素節(jié)點中的value進(jìn)行了替換
        //在其它方法中check=1可能表示在指定的索引位置上添加了1個元素節(jié)點
        //如果是這三種情況的話則不會去嘗試進(jìn)行擴(kuò)容
        //如果執(zhí)行到了當(dāng)前判斷語句的話則說明并沒有執(zhí)行上面的fullAddCount方法
        //而是通過上面判斷語句中的cas操作對指定索引位置上的計數(shù)器對象的值操作成功
        //但是在check=1的情況下的put方法只是將原本的元素節(jié)點中的value替換了
        //如果此時還要對計數(shù)器對象中的value加1,那不就會造成1個元素節(jié)點變成了2個元素節(jié)點?
        //其實并不會的,如果check=1的情況下put方法并不會走到當(dāng)前的方法中
        if (check <= 1)
            return;
        //將計數(shù)器數(shù)組中所有的計數(shù)器對象值以及基本的計數(shù)器值合并獲取到當(dāng)前集合中的元素節(jié)點的數(shù)量
        s = sumCount();
    }
    //校驗check是否大于等于0
    //大于等于0則說明添加了新的元素節(jié)點
    //此時就需要來校驗是否需要進(jìn)行擴(kuò)容
    //check一共分為5種情況,有三種已經(jīng)在上面說過,現(xiàn)在來看一下剩下的兩種情況
    //check=2的情況下代表在紅黑樹種添加了一個樹節(jié)點,也有可能是在一個鏈表節(jié)點中添加了一個節(jié)點
    //check>2的情況下代表在鏈表節(jié)點中添加了一個節(jié)點
    if (check >= 0) {
        Node<K, V>[] tab, nt;
        int n, sc;
        //當(dāng)前數(shù)組中的元素節(jié)點的數(shù)量已經(jīng)到達(dá)擴(kuò)容的閾值并且數(shù)組的長度小于數(shù)組最大容量大小
        //此時會嘗試將數(shù)組進(jìn)行擴(kuò)容,如果擴(kuò)容失敗則會一直進(jìn)行嘗試,直到擴(kuò)容成功
        while (s >= (long) (sc = sizeCtl) && (tab = table) != null && (n = tab.length) < MAXIMUM_CAPACITY) {
            //獲取擴(kuò)容時的標(biāo)記
            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;
                //擴(kuò)容線程加1
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    //協(xié)助擴(kuò)容
                    transfer(tab, nt);
            //將sizeCtl修改成一個很大的負(fù)數(shù),告知其它線程現(xiàn)在有線程正在擴(kuò)容
            //為什么要+2而不是+1?+1代表當(dāng)前擴(kuò)容的線程數(shù)量+1,而+2可能是標(biāo)識開啟擴(kuò)容
            } else if (U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2))
                //擴(kuò)容
                transfer(tab, null);
            //重新計算集合中元素節(jié)點的數(shù)量
            s = sumCount();
        }
    }
}

private final void fullAddCount(long x, boolean wasUncontended) {
    int h;
    //使用當(dāng)前線程生成隨機(jī)數(shù),如果隨機(jī)數(shù)為0則說明ThreadLocalRandom中的一些參數(shù)還未被初始化
    //此時就需要進(jìn)行初始化并重新獲取隨機(jī)數(shù)
    if ((h = ThreadLocalRandom.getProbe()) == 0) {
        ThreadLocalRandom.localInit();
        h = ThreadLocalRandom.getProbe();
        wasUncontended = true;
    }
    boolean collide = false;
    for (; ; ) {
        //計數(shù)器數(shù)組
        CounterCell[] as;
        //計數(shù)器對象
        CounterCell a;
        //計數(shù)器數(shù)組長度
        int n;
        //計數(shù)器對象中的value
        long v;
        //校驗計數(shù)器數(shù)組是否已初始化
        if ((as = counterCells) != null && (n = as.length) > 0) {
            //校驗當(dāng)前線程生成的隨機(jī)數(shù)與計數(shù)器數(shù)組索引長度運(yùn)算后獲取到的指定索引位置上的計數(shù)器對象是否為空
            if ((a = as[(n - 1) & h]) == null) {
                //校驗計數(shù)器數(shù)組的鎖狀態(tài)是否為0
                //如果不為0則說明有其它線程正在對計數(shù)器數(shù)組進(jìn)行擴(kuò)容或?qū)τ嫈?shù)器數(shù)組中的計數(shù)器對象進(jìn)行初始化
                if (cellsBusy == 0) {
                    //創(chuàng)建一個計數(shù)器對象,并將值添加到計數(shù)器對象中
                    CounterCell r = new CounterCell(x);
                    //加鎖,防止多個線程同時對通一個索引位置上的計數(shù)器對象進(jìn)行初始化
                    if (cellsBusy == 0 && U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                        boolean created = false;
                        try {
                            CounterCell[] rs;
                            int m, j;
                            //校驗一下運(yùn)算后的索引位置上的計數(shù)器對象是否為空
                            //如果不為空則說明已經(jīng)被其它線程初始化了,當(dāng)前線程就不需要再去初始化
                            if ((rs = counterCells) != null && (m = rs.length) > 0 && rs[j = (m - 1) & h] == null) {
                                //將創(chuàng)建好的計數(shù)器對象添加到運(yùn)算后的指定索引位置上
                                rs[j] = r;
                                //初始化成功
                                created = true;
                            }
                        } finally {
                            //修改計數(shù)器數(shù)組鎖標(biāo)識
                            cellsBusy = 0;
                        }
                        if (created)
                            //初始化成功則退出
                            break;
                        //初始化失敗,說明已經(jīng)有其它線程初始化了計數(shù)器對象,此時就需要重新走循環(huán)選擇初始化成功的計數(shù)器對象進(jìn)行操作
                        continue;
                    }
                }
                //其它線程正在對計數(shù)器數(shù)組進(jìn)行擴(kuò)容或初始化指定索引位置上的計數(shù)器對象
                collide = false;
            } else if (!wasUncontended)
                //wasUncontended為false則說明有其它線程正在對指定索引位置上的計數(shù)器對象進(jìn)行操作
                //此時當(dāng)前線程則需要獲取其它索引位置上的計數(shù)器對象進(jìn)行操作
                wasUncontended = true;
            //嘗試對指定索引位置上的計數(shù)器對象進(jìn)行操作
            else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
                //執(zhí)行成功則退出
                break;
            //校驗當(dāng)前是否有線程對計數(shù)器數(shù)組進(jìn)行了擴(kuò)容,將計數(shù)器數(shù)組中的計數(shù)器對象移動到了新的計數(shù)器數(shù)組中
            //如果已經(jīng)將計數(shù)器對象移動到了新的計數(shù)器數(shù)組中,那重新選擇新的計數(shù)器數(shù)組中的計數(shù)器對象來進(jìn)行操作
            //如果沒有線程對計數(shù)器數(shù)組進(jìn)行擴(kuò)容,那比較一下當(dāng)前計數(shù)器數(shù)組的長度是否大于等于cpu的數(shù)量
            //如果大于等于cpu的數(shù)量則不會進(jìn)行擴(kuò)容,只會重新選擇計數(shù)器數(shù)組中的計數(shù)器對象來操作
            //如果計數(shù)器數(shù)組的長度小于cpu的數(shù)量那就會對計數(shù)器數(shù)組進(jìn)行2倍的擴(kuò)容
            else if (counterCells != as || n >= NCPU)
                //此處將collide修改為false可能是想再次嘗試一下是否能對計數(shù)器數(shù)組中的計數(shù)器對象進(jìn)行操作
                //如果能操作則不進(jìn)行擴(kuò)容,這樣能減少擴(kuò)容帶來的性能問題
                collide = false;
            else if (!collide)
                collide = true;
            //多次獲取計數(shù)器數(shù)組中的計數(shù)器對象而不能操作,并計數(shù)器數(shù)組的長度小于cpu的數(shù)量
            //導(dǎo)致部分的cpu沒有被使用到,此時就需要對計數(shù)器數(shù)組進(jìn)行擴(kuò)容,充分的使用cpu
            //對計數(shù)器數(shù)組加鎖
            else if (cellsBusy == 0 && U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                try {
                    //校驗計數(shù)器數(shù)組是否變更,防止其它線程已經(jīng)對計數(shù)器數(shù)組進(jìn)行了擴(kuò)容
                    if (counterCells == as) {
                        //初始化一個新的計數(shù)器數(shù)組,大小是原來的2倍
                        CounterCell[] rs = new CounterCell[n << 1];
                        //循環(huán)將原來的計數(shù)器數(shù)組中的計數(shù)器對象移動到擴(kuò)容后的計數(shù)器數(shù)組中
                        for (int i = 0; i < n; ++i)
                            rs[i] = as[i];
                        //更新當(dāng)前集合中的計數(shù)器數(shù)組
                        counterCells = rs;
                    }
                } finally {
                    //修改計數(shù)器數(shù)組鎖標(biāo)識
                    cellsBusy = 0;
                }
                collide = false;
                //使用擴(kuò)容后的計數(shù)器數(shù)組進(jìn)行操作
                continue;
            }
            //計數(shù)器對象正在被其它線程操作,此時需要重新生成隨機(jī)數(shù),獲取別的索引位置上的計數(shù)器對象來進(jìn)行操作
            h = ThreadLocalRandom.advanceProbe(h);
        //計數(shù)器數(shù)組未被初始化,此時就需要校驗一下當(dāng)前是否有其它線程正在初始化計數(shù)器數(shù)組
        //如果沒有,那當(dāng)前線程就需要將計數(shù)器數(shù)組初始化的標(biāo)識設(shè)置為1,代表當(dāng)前有線程正在初始化計數(shù)器數(shù)組
        } else if (cellsBusy == 0 && counterCells == as && U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
            boolean init = false;
            try {
                if (counterCells == as) {
                    //創(chuàng)建計數(shù)器數(shù)組,計數(shù)器數(shù)組的長度為2的次方
                    CounterCell[] rs = new CounterCell[2];
                    //創(chuàng)建一個計數(shù)器對象,并將值添加到計數(shù)器對象中
                    //并使用線程生成的隨機(jī)數(shù)與計數(shù)器數(shù)組索引長度進(jìn)行運(yùn)算獲取到指定的索引位置
                    //并將計數(shù)器對象放置到指定的索引位置上
                    rs[h & 1] = new CounterCell(x);
                    //更新當(dāng)前集合中的計數(shù)器數(shù)組
                    counterCells = rs;
                    //初始化完成
                    init = true;
                }
            } finally {
                //修改計數(shù)器數(shù)組鎖標(biāo)識
                cellsBusy = 0;
            }
            if (init)
                //計數(shù)器數(shù)組初始化完成則退出
                break;
        //計數(shù)器數(shù)組正在被其它線程初始化或已經(jīng)被其它線程初始化完成
        //此時嘗試對基本的計數(shù)器值進(jìn)行操作
        //如果失敗則說明有其它線程也在對基本計數(shù)器值進(jìn)行操作
        //那就要重新走循環(huán),來看計數(shù)器數(shù)組是否被初始化完成,如果被初始化完成那就對計數(shù)器數(shù)組中的計數(shù)器對象進(jìn)行操作
        //如果還沒有初始化完成則會繼續(xù)嘗試對基本的計數(shù)器值進(jìn)行操作
        } else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
            break;
    }
}

private final void transfer(Node<K, V>[] tab, Node<K, V>[] nextTab) {
    //n 數(shù)組長度
    //stride 每個cpu需要負(fù)責(zé)轉(zhuǎn)移的索引長度
    int n = tab.length, stride;
    //使用數(shù)組長度來計算每個cpu需要負(fù)責(zé)的長度
    //每個cpu最少需要負(fù)責(zé)16的長度
    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
        stride = MIN_TRANSFER_STRIDE;
    //nextTab為空則說明當(dāng)前沒有其它線程在初始化
    //不為空則說明當(dāng)前有其它線程正在初始化,當(dāng)前線程則需要幫助初始化的線程將舊數(shù)組中的元素節(jié)點轉(zhuǎn)移到新的數(shù)組中
    if (nextTab == null) {
        try {
            //創(chuàng)建新的數(shù)組,容量是舊數(shù)組的2倍
            @SuppressWarnings("unchecked")
            Node<K, V>[] nt = (Node<K, V>[]) new Node<?, ?>[n << 1];
            nextTab = nt;
        } catch (Throwable ex) {
            //出現(xiàn)異常時則說明擴(kuò)容失敗,容量大小已經(jīng)超出MAXIMUM_CAPACITY參數(shù)指定的最大的數(shù)組容量
            //因為MAXIMUM_CAPACITY參數(shù)指定的容量大小是int類型中正整數(shù)最大的2的次方
            //當(dāng)數(shù)組的長度已經(jīng)到達(dá)MAXIMUM_CAPACITY參數(shù)指定的容量大小時,如果再進(jìn)行2倍的擴(kuò)容就會導(dǎo)致數(shù)組的長度變成負(fù)數(shù)
            //此時就會導(dǎo)致擴(kuò)容失敗,將int類型中最大的正整數(shù)設(shè)置成擴(kuò)容的閾值來停止本次擴(kuò)容
            //如果數(shù)組的長度已到達(dá)數(shù)組最大的容量大小那就不會進(jìn)行擴(kuò)容了
            sizeCtl = Integer.MAX_VALUE;
            return;
        }
        //擴(kuò)容后的數(shù)組,當(dāng)其它擴(kuò)容的線程發(fā)現(xiàn)nextTable不為空時則不會重復(fù)擴(kuò)容
        nextTable = nextTab;
        //擴(kuò)容后,默認(rèn)需要轉(zhuǎn)移整個舊數(shù)組
        transferIndex = n;
    }
    //獲取擴(kuò)容后的數(shù)組長度
    int nextn = nextTab.length;
    //創(chuàng)建一個轉(zhuǎn)移的節(jié)點
    ForwardingNode<K, V> fwd = new ForwardingNode<K, V>(nextTab);
    //是否繼續(xù)轉(zhuǎn)移
    boolean advance = true;
    //標(biāo)識擴(kuò)容之后舊數(shù)組中的節(jié)點是否全部完成轉(zhuǎn)移
    boolean finishing = false;
    for (int i = 0, bound = 0; ; ) {
        Node<K, V> f;
        int fh;
        while (advance) {
            //nextIndex 當(dāng)前線程開始轉(zhuǎn)移的長度位置
            //nextBound 當(dāng)前線程負(fù)責(zé)轉(zhuǎn)移的索引位置邊界,如果到達(dá)這個邊界則說明當(dāng)前線程已經(jīng)完成了所負(fù)責(zé)的索引長度的節(jié)點
            //轉(zhuǎn)移舊數(shù)組中的元素節(jié)點是從數(shù)組的尾部向數(shù)組的頭部開始轉(zhuǎn)移
            int nextIndex, nextBound;
            //每次轉(zhuǎn)移完一個索引位置上的節(jié)點的時候都會校驗一下下一次轉(zhuǎn)移的索引位置是否已經(jīng)超出邊界
            //或舊數(shù)組中的元素節(jié)點都已經(jīng)全部轉(zhuǎn)移完成
            //如果下一次轉(zhuǎn)移的索引位置超出邊界,但是剩下需要轉(zhuǎn)移的節(jié)點沒有被其它線程協(xié)助轉(zhuǎn)移
            //那么當(dāng)前線程則繼續(xù)選擇部分的索引長度來轉(zhuǎn)移
            if (--i >= bound || finishing)
                advance = false;
            //校驗剩余需要轉(zhuǎn)移的索引長度是否為0,如果為0則說明舊數(shù)組中沒有需要轉(zhuǎn)移的元素節(jié)點了
            else if ((nextIndex = transferIndex) <= 0) {
                //將轉(zhuǎn)移的節(jié)點的索引位置設(shè)置為-1,后續(xù)會根據(jù)該條件退出擴(kuò)容方法
                i = -1;
                advance = false;
            //根據(jù)開始轉(zhuǎn)移的長度位置與每個線程需要轉(zhuǎn)移的長度進(jìn)行比較
            //如果開始轉(zhuǎn)移的長度位置大于每個線程需要轉(zhuǎn)移的長度,那就使用開始轉(zhuǎn)移的長度位置減去每個線程需要轉(zhuǎn)移的長度
            //獲取到當(dāng)前線程需要負(fù)責(zé)轉(zhuǎn)移的索引位置邊界
            //如果開始轉(zhuǎn)移的長度位置小于等于每個線程需要轉(zhuǎn)移的長度,那就說明當(dāng)前需要轉(zhuǎn)移的長度不需要其它線程協(xié)助
            //當(dāng)前線程則會將剩下需要轉(zhuǎn)移的節(jié)點轉(zhuǎn)移到新的數(shù)組中
            } else if (U.compareAndSwapInt(this, TRANSFERINDEX, nextIndex, nextBound = (nextIndex > stride ? nextIndex - stride : 0))) {
                //將計算后的索引邊界賦予bound,用于線程每次轉(zhuǎn)移之后進(jìn)行校驗
                //如果已經(jīng)到達(dá)了邊界說明線程已經(jīng)完成了所負(fù)責(zé)的索引長度的節(jié)點轉(zhuǎn)移
                //線程不再執(zhí)行節(jié)點的轉(zhuǎn)移
                bound = nextBound;
                //開始轉(zhuǎn)移的長度位置-1,獲取到開始轉(zhuǎn)移的節(jié)點的索引位置
                i = nextIndex - 1;
                advance = false;
            }
        }
        //i < 0 小于0則說明當(dāng)前線程所負(fù)責(zé)轉(zhuǎn)移的節(jié)點已經(jīng)完成并且沒有其它需要轉(zhuǎn)移的節(jié)點了
        //i >= n
        //i + n >= nextn
        if (i < 0 || i >= n || i + n >= nextn) {
            int sc;
            //當(dāng)前finishing為true時則說明舊數(shù)組中的所有節(jié)點都已經(jīng)轉(zhuǎn)移
            //此時就需要將新數(shù)組設(shè)置為當(dāng)前集合使用的數(shù)組并計算下一次的擴(kuò)容閾值
            if (finishing) {
                //將擴(kuò)容的數(shù)組置為空,代表當(dāng)前沒有線程正在進(jìn)行擴(kuò)容操作
                nextTable = null;
                //將擴(kuò)容后的新數(shù)組設(shè)置為當(dāng)前集合正在使用的數(shù)組
                table = nextTab;
                //計算下一次擴(kuò)容的閾值
                sizeCtl = (n << 1) - (n >>> 1);
                //擴(kuò)容完成,退出
                return;
            }
            //finishing為false則會走到當(dāng)前語句,則說明當(dāng)前線程并不知道舊數(shù)組中的元素節(jié)點有沒有轉(zhuǎn)移完成
            //但是當(dāng)前線程所負(fù)責(zé)轉(zhuǎn)移的索引節(jié)點已經(jīng)完成,此時就需要將并發(fā)擴(kuò)容中的線程數(shù)量減1
            if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                //擴(kuò)容標(biāo)記左移16位獲取到線程數(shù)量的標(biāo)記
                //使用sc-2獲取到當(dāng)前還剩下的線程數(shù)量的標(biāo)記
                //如果兩個相等則說明當(dāng)前線程是最后一個擴(kuò)容結(jié)束的線程
                //此時就需要當(dāng)前線程執(zhí)行收尾操作,需要從舊數(shù)組中的尾部開始向頭部節(jié)點遍歷來檢查是否所有的元素節(jié)點都轉(zhuǎn)移了
                //如果都轉(zhuǎn)移了,則將擴(kuò)容后的新數(shù)組設(shè)置為當(dāng)前集合正在使用的數(shù)組,并且計算下一次擴(kuò)容的閾值
                //如果還有元素節(jié)點沒有轉(zhuǎn)移,當(dāng)前線程則會將剩下的元素節(jié)點進(jìn)行轉(zhuǎn)移
                //如果兩個不相等則說明當(dāng)前線程不是最后一個擴(kuò)容結(jié)束的線程
                //當(dāng)前線程已經(jīng)完成了所負(fù)責(zé)的索引位置的元素節(jié)點,并且舊數(shù)組中沒有其他需要轉(zhuǎn)移的節(jié)點了,當(dāng)前線程直接退出擴(kuò)容
                if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                    return;
                //當(dāng)前線程是最后一個結(jié)束擴(kuò)容的線程,此時就需要檢查舊數(shù)組中是否所有的元素節(jié)點都轉(zhuǎn)移了
                finishing = advance = true;
                //從舊數(shù)組的尾部開始檢查
                i = n;
            }
        } else if ((f = tabAt(tab, i)) == null)
            //如果指定索引位置上的節(jié)點為空則直接將舊數(shù)組中該索引位置上的節(jié)點設(shè)置成一個正在轉(zhuǎn)移的節(jié)點進(jìn)行占位
            //當(dāng)有新的線程要對該索引位置的節(jié)點操作的時候則會發(fā)現(xiàn)該索引位置上的節(jié)點是一個正在轉(zhuǎn)移的節(jié)點
            //則不會對該索引位置上的節(jié)點進(jìn)行操作而是先協(xié)助擴(kuò)容線程進(jìn)行轉(zhuǎn)移
            advance = casTabAt(tab, i, null, fwd);
        else if ((fh = f.hash) == MOVED)
            //指定索引位置上的節(jié)點已經(jīng)被其它線程處理過
            advance = true;
        else {
            //加鎖,防止其它線程對當(dāng)前需要移動的節(jié)點進(jìn)行操作
            synchronized (f) {
                //校驗節(jié)點是否變更
                if (tabAt(tab, i) == f) {
                    //ln 低位節(jié)點,該節(jié)點放置到新數(shù)組中的索引位置與在舊數(shù)組中的索引位置相同
                    //hn 高位節(jié)點,該節(jié)點放置到新數(shù)組中的索引位置是在舊數(shù)組中的索引位置加上舊數(shù)組的長度
                    Node<K, V> ln, hn;
                    //校驗節(jié)點的hash值是否大于等于0
                    //如果節(jié)點的hash值大于等于0則說明該索引位置上只有一個節(jié)點或節(jié)點是一個鏈表節(jié)點
                    if (fh >= 0) {
                        //使用節(jié)點的hash值與舊數(shù)組的長度進(jìn)行與運(yùn)算
                        //與運(yùn)算后的結(jié)果分為0和1,0則將該節(jié)點放置到低位,1則將節(jié)點放置高位
                        int runBit = fh & n;
                        //避免后續(xù)轉(zhuǎn)移節(jié)點的時候沒有必要的循環(huán)以及創(chuàng)建節(jié)點
                        Node<K, V> lastRun = f;
                        //遍歷整個鏈表來決定從那個節(jié)點開始以及后續(xù)的節(jié)點都是沒有必要遍歷和創(chuàng)建的
                        //而是直接使用指針指向舊數(shù)組中的節(jié)點,當(dāng)擴(kuò)容完成之后舊數(shù)組以及舊數(shù)組中部分沒有被指針引用的節(jié)點則會被回收
                        for (Node<K, V> p = f.next; p != null; p = p.next) {
                            int b = p.hash & n;
                            if (b != runBit) {
                                runBit = b;
                                lastRun = p;
                            }
                        }
                        //沒有必要循環(huán)和創(chuàng)建的節(jié)點應(yīng)該放置到新數(shù)組中的低為還是高位
                        if (runBit == 0) {
                            //低位
                            ln = lastRun;
                            hn = null;
                        } else {
                            //高位
                            hn = lastRun;
                            ln = null;
                        }
                        //從頭節(jié)點開始遍歷將需要重新創(chuàng)建的節(jié)點進(jìn)行創(chuàng)建并添加到高位或低位
                        //在添加到高位或低位的時候,新創(chuàng)建的節(jié)點使用的是頭插法
                        //如果有節(jié)點不需要重新創(chuàng)建,那不需要重新創(chuàng)建的節(jié)點則會放到高位或低位節(jié)點的尾部
                        //在上面的時候如果不需要重新創(chuàng)建的節(jié)點其實就已經(jīng)放在了ln或hn中
                        //當(dāng)有節(jié)點重新創(chuàng)建了的時候,則ln或hn設(shè)置為新創(chuàng)建的節(jié)點的下一個節(jié)點
                        //其實整體來說就是頭插法,如果說整個鏈表或部分連續(xù)的鏈表節(jié)點不需要重新創(chuàng)建的時候還是保持在舊數(shù)組中一樣的順序
                        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);
                        }
                        //將低位節(jié)點鏈表添加到新數(shù)組中所在的索引位置與舊數(shù)組所在的索引位置相同
                        setTabAt(nextTab, i, ln);
                        //將高位節(jié)點鏈表添加到新數(shù)組中所在的索引位置是在舊數(shù)組中所在的索引位置加上舊數(shù)組的長度
                        setTabAt(nextTab, i + n, hn);
                        //將舊數(shù)組中的索引位置上的節(jié)點設(shè)置為一個已經(jīng)轉(zhuǎn)移的節(jié)點
                        setTabAt(tab, i, fwd);
                        //繼續(xù)推進(jìn)下一次節(jié)點轉(zhuǎn)移
                        advance = true;
                    //節(jié)點是一個紅黑樹節(jié)點
                    } else if (f instanceof TreeBin) {
                        TreeBin<K, V> t = (TreeBin<K, V>) f;
                        //低位頭節(jié)點和尾節(jié)點
                        TreeNode<K, V> lo = null, loTail = null;
                        //高位頭節(jié)點和尾節(jié)點
                        TreeNode<K, V> hi = null, hiTail = null;
                        //低位節(jié)點和高位節(jié)點的數(shù)量
                        int lc = 0, hc = 0;
                        //從TreeBin對象中記錄的鏈表的頭節(jié)點開始遍歷將每一個節(jié)點分為低位節(jié)點和高位節(jié)點
                        for (Node<K, V> e = t.first; e != null; e = e.next) {
                            int h = e.hash;
                            //構(gòu)造新的樹節(jié)點
                            TreeNode<K, V> p = new TreeNode<K, V>(h, e.key, e.val, null, null);
                            if ((h & n) == 0) {
                                //將構(gòu)造的樹節(jié)點的上一個節(jié)點指針指向原低位尾節(jié)點
                                //如果原低尾節(jié)點為空則說明當(dāng)前樹節(jié)點是第一個節(jié)點
                                //那就將當(dāng)前樹節(jié)點設(shè)置為低位頭節(jié)點
                                if ((p.prev = loTail) == null)
                                    lo = p;
                                else
                                    //原低位尾節(jié)點不為空則將原尾節(jié)點的下一個節(jié)點指針指向當(dāng)前樹節(jié)點
                                    loTail.next = p;
                                //將新構(gòu)造的樹節(jié)點設(shè)置為低位尾節(jié)點
                                loTail = p;
                                //低位節(jié)點的數(shù)量自增
                                ++lc;
                            } else {
                                if ((p.prev = hiTail) == null)
                                    hi = p;
                                else
                                    hiTail.next = p;
                                hiTail = p;
                                ++hc;
                            }
                        }
                        //拆分后的高低位節(jié)點的數(shù)量是否小于等于紅黑樹轉(zhuǎn)鏈表的閾值
                        //如果小于等于則調(diào)用untreeify方法將樹節(jié)點轉(zhuǎn)換為鏈表節(jié)點
                        //如果高位節(jié)點數(shù)量或低位節(jié)點數(shù)量大于閾值則會校驗對方節(jié)點的數(shù)量是否不等于0
                        //如果說對方的節(jié)點數(shù)量等于0則說明節(jié)點并沒有拆分為高位或低位節(jié)點
                        //那就使用原本的TreeBin對象進(jìn)行轉(zhuǎn)移
                        //如果對方的節(jié)點數(shù)量大于0則說明已經(jīng)拆分為了高低位節(jié)點
                        //此時就需要將高低位節(jié)點轉(zhuǎn)換為紅黑樹并封裝成一個TreeBin對象
                        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;
                        //將低位節(jié)點TreeBin對象添加到新數(shù)組中所在的索引位置與舊數(shù)組所在的索引位置相同
                        setTabAt(nextTab, i, ln);
                        //將高位節(jié)點TreeBin添加到新數(shù)組中所在的索引位置是在舊數(shù)組中所在的索引位置加上舊數(shù)組的長度
                        setTabAt(nextTab, i + n, hn);
                        //將舊數(shù)組中的索引位置上的節(jié)點設(shè)置為一個已經(jīng)轉(zhuǎn)移的節(jié)點
                        setTabAt(tab, i, fwd);
                        //繼續(xù)推進(jìn)下一次節(jié)點轉(zhuǎn)移
                        advance = true;
                    }
                }
            }
        }
    }
}

int n = tab.length, stride;
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
    stride = MIN_TRANSFER_STRIDE;
if (nextTab == null) {
    try {
        @SuppressWarnings("unchecked")
        Node<K, V>[] nt = (Node<K, V>[]) new Node<?, ?>[n << 1];
        nextTab = nt;
    } catch (Throwable ex) {
        sizeCtl = Integer.MAX_VALUE;
        return;
    }
    nextTable = nextTab;
    transferIndex = n;
}

ForwardingNode<K, V> fwd = new ForwardingNode<K, V>(nextTab);
ForwardingNode(Node<K,V>[] tab) {
    super(MOVED, null, null, null);
    this.nextTable = tab;
}

while (advance) {
    int nextIndex, nextBound;
    if (--i >= bound || finishing)
        advance = false;
    else if ((nextIndex = transferIndex) <= 0) {
        i = -1;
        advance = false;
    } else if (U.compareAndSwapInt(this, TRANSFERINDEX, nextIndex, nextBound = (nextIndex > stride ? nextIndex - stride : 0))) {
        bound = nextBound;
        i = nextIndex - 1;
        advance = false;
    }
}

if (i < 0 || i >= n || i + n >= nextn) {
    int sc;
    if (finishing) {
        nextTable = null;
        table = nextTab;
        sizeCtl = (n << 1) - (n >>> 1);
        return;
    }
    if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
        if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
            return;
        finishing = advance = true;
        i = n;
    }
}

else if ((f = tabAt(tab, i)) == null)
    advance = casTabAt(tab, i, null, fwd);

else if ((fh = f.hash) == MOVED)
    advance = true;

synchronized (f) {
    if (tabAt(tab, i) == f) {
        Node<K, V> ln, hn;
        if (fh >= 0) {
            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);
            }
            setTabAt(nextTab, i, ln);
            setTabAt(nextTab, i + n, hn);
            setTabAt(tab, i, fwd);
            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;
        }
    }
}