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

/**
 * 創(chuàng)建一個(gè)默認(rèn)容量為16的數(shù)組對(duì)象
 * 該構(gòu)造方法中并沒有執(zhí)行任何操作
 * 并沒有創(chuàng)建默認(rèn)容量的數(shù)組對(duì)象
 * 只有在第一次添加元素的時(shí)候才會(huì)初始化數(shù)組對(duì)象
 */
public ConcurrentHashMap() {
}
/**
 * 創(chuàng)建一個(gè)指定初始容量的數(shù)組對(duì)象
 * @param initialCapacity 指定的初始容量
 */
public ConcurrentHashMap(int initialCapacity) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException();
    //校驗(yàn)指定的初始容量大小是否大于等于最大容量大小的一半
    //如果大于等于最大容量大小的一半則在后續(xù)第一次添加元素的時(shí)候使用最大容量大小創(chuàng)建數(shù)組
    //如果小于最大容量大小的一半則根據(jù)指定容量來計(jì)算最接近指定容量大小并大于指定容量的2的次方
    //此處有一個(gè)疑問,指定容量大小如果等于最大容量大小的一半則說明指定容量大小是2的29次方,為什么不使用指定容量大小,而是使用最大的容量大小?
    //從tableSizeFor方法也能看出,如果指定的初始容量大小本來就是2的次方的話并不會(huì)使用指定的初始容量大小來創(chuàng)建數(shù)組對(duì)象
    //而是使用大于指定初始容量大小的2的次方來創(chuàng)建數(shù)組對(duì)象,比如指定的初始容量大小為16,那就會(huì)使用32來創(chuàng)建數(shù)組對(duì)象
    //在HashMap中如果指定的初始容量大小本來就是2的次方的話則會(huì)使用指定的初始容量大小來創(chuàng)建數(shù)組對(duì)象
    //并不會(huì)像ConcurrentHashMap一樣會(huì)取比當(dāng)前指定的2的次方的初始容量大小大的2的次方的容量大小來創(chuàng)建數(shù)組對(duì)象
    int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
            MAXIMUM_CAPACITY : tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
    //將計(jì)算后的容量大小賦值給sizeCtl等待初始化
    this.sizeCtl = cap;
}
/**
 * 根據(jù)指定的集合中的元素來創(chuàng)建新的數(shù)組對(duì)象
 * @param m the map
 */
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
    //使用默認(rèn)的初始容量大小等待初始化
    this.sizeCtl = DEFAULT_CAPACITY;
    //初始化新的數(shù)組對(duì)象并將指定集合中的元素添加到新的數(shù)組對(duì)象中
    putAll(m);
}
/**
 * 根據(jù)指定的初始容量大小和指定的負(fù)載因子來創(chuàng)建新的數(shù)組對(duì)象
 */
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
    this(initialCapacity, loadFactor, 1);
}
/**
 * 根據(jù)指定的初始容量大小和指定的負(fù)載因子和并發(fā)數(shù)來創(chuàng)建新的數(shù)組對(duì)象
 */
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ù)組對(duì)象
        initialCapacity = concurrencyLevel;
    //通過計(jì)算獲取到擴(kuò)容的閾值
    long size = (long) (1.0 + (long) initialCapacity / loadFactor);
    //如果閾值大于等于最大容量大小則使用最大容量大小來創(chuàng)建新的數(shù)組對(duì)象
    //如果閾值小于最大容量大小則使用閾值來計(jì)算獲取到大于閾值并是2的次方的值
    //使用計(jì)算后的值來創(chuàng)建新的數(shù)組對(duì)象
    int cap = (size >= (long) MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : tableSizeFor((int) size);
    //將計(jì)算后的容量大小賦值給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é)點(diǎn)的數(shù)量
    int binCount = 0;
    for (Node<K, V>[] tab = table; ; ) {
        //數(shù)組中指定索引的節(jié)點(diǎn)
        Node<K, V> f;
        //n 數(shù)組長度
        //i key所在的數(shù)組索引位置
        //fh 指定索引的節(jié)點(diǎn)的hash值
        int n, i, fh;
        //校驗(yàn)數(shù)組是否已經(jīng)初始化
        if (tab == null || (n = tab.length) == 0)
            //數(shù)組未初始化則初始化數(shù)組
            //并返回初始化完成的數(shù)組對(duì)象
            tab = initTable();
        //通過數(shù)組索引長度與key的hash值進(jìn)行與運(yùn)算獲取到指定索引位置上的元素節(jié)點(diǎn),并校驗(yàn)元素節(jié)點(diǎn)是否為空
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            //指定索引位置上的節(jié)點(diǎn)不存在則使用傳遞進(jìn)來的key和value創(chuàng)建新的節(jié)點(diǎn)
            //并將新的節(jié)點(diǎn)放置到指定索引位置上
            if (casTabAt(tab, i, null,new Node<K, V>(hash, key, value, null)))
                //節(jié)點(diǎn)添加成功則退出循環(huán)
                break;
        //校驗(yàn)索引位置上的節(jié)點(diǎn)是否正在移動(dòng)
        } else if ((fh = f.hash) == MOVED)
            //如果索引位置上的節(jié)點(diǎn)正在移動(dòng)則幫忙移動(dòng)節(jié)點(diǎn)到新的數(shù)組中
            //協(xié)助擴(kuò)容
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            //使用鎖鎖住指定索引位置上的節(jié)點(diǎn)
            //這樣其它線程就不能對(duì)該索引位置上的節(jié)點(diǎn)進(jìn)行操作
            //其它線程可以對(duì)其它索引位置上的節(jié)點(diǎn)進(jìn)行操作
            synchronized (f) {
                //校驗(yàn)指定索引位置上的節(jié)點(diǎn)是否被更改
                if (tabAt(tab, i) == f) {
                    //校驗(yàn)節(jié)點(diǎn)的hash值是否大于等于0
                    //如果節(jié)點(diǎn)的hash值大于等于0則說明該索引位置上只有一個(gè)節(jié)點(diǎn)或節(jié)點(diǎn)是一個(gè)鏈表節(jié)點(diǎn)
                    if (fh >= 0) {
                        binCount = 1;
                        //從指定索引位置上的節(jié)點(diǎn)開始遍歷
                        for (Node<K, V> e = f; ; ++binCount) {
                            K ek;
                            //校驗(yàn)遍歷到的節(jié)點(diǎn)的hash值以及key是否與傳遞的key和計(jì)算的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é)點(diǎn)的hash值以及key不相同
                            //則判斷當(dāng)前遍歷到的節(jié)點(diǎn)是否是鏈表上的最后一個(gè)節(jié)點(diǎn)
                            //如果不是最后一個(gè)節(jié)點(diǎn)則繼續(xù)遍歷
                            //如果是最后一個(gè)節(jié)點(diǎn)則為key和value創(chuàng)建一個(gè)新的節(jié)點(diǎn)
                            //并將原尾節(jié)點(diǎn)的next指針指向新創(chuàng)建的節(jié)點(diǎn)
                            Node<K, V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K, V>(hash, key, value, null);
                                break;
                            }
                        }
                     //校驗(yàn)節(jié)點(diǎn)是否是一個(gè)紅黑樹節(jié)點(diǎn)
                    } else if (f instanceof TreeBin) {
                        Node<K, V> p;
                        binCount = 2;
                        //將指定的key和value封裝成一個(gè)樹節(jié)點(diǎn)并添加到紅黑樹中
                        //如果紅黑樹中已經(jīng)存在相同key的節(jié)點(diǎn)則根據(jù)onlyIfAbsent參數(shù)來決定是否使用新的value替換紅黑樹中的節(jié)點(diǎn)的value
                        if ((p = ((TreeBin<K, V>) f).putTreeVal(hash, key,value)) != null) {
                            //獲取節(jié)點(diǎn)中的舊值
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                //替換節(jié)點(diǎn)中的value
                                p.val = value;
                        }
                    }
                }
            }
            if (binCount != 0) {
                //校驗(yàn)索引位置上的節(jié)點(diǎn)的數(shù)量是否到達(dá)樹化的閾值
                //如果該索引位置上的節(jié)點(diǎn)本來就是樹節(jié)點(diǎn)則不會(huì)繼續(xù)樹化
                //只有當(dāng)索引位置上的節(jié)點(diǎn)是鏈表節(jié)點(diǎn)并且節(jié)點(diǎn)的數(shù)量大于等于8的時(shí)候才會(huì)樹化
                if (binCount >= TREEIFY_THRESHOLD)
                    //索引位置上的節(jié)點(diǎn)數(shù)量已經(jīng)到達(dá)樹化的閾值
                    //則將該索引位置上的所有節(jié)點(diǎn)轉(zhuǎn)換為樹節(jié)點(diǎn)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    //返回被替換的舊值
                    return oldVal;
                break;
            }
        }
    }
    //更新集合中元素節(jié)點(diǎn)的數(shù)量,并校驗(yàn)是否需要擴(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;
    //校驗(yàn)數(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ù)組對(duì)象賦值給當(dāng)前集合中的數(shù)組對(duì)象
                    //并賦值給tab,下一次循環(huán)校驗(yàn)則會(huì)發(fā)現(xiàn)tab不為空則會(huì)退出循環(huán)并退出當(dāng)前方法
                    table = tab = nt;
                    //計(jì)算數(shù)組擴(kuò)容的閾值
                    sc = n - (n >>> 2);
                }
            } finally {
                //如果try中的代碼塊執(zhí)行失敗時(shí)sizeCtl則是原先數(shù)組的長度
                //執(zhí)行成功時(shí)sizeCtl則是擴(kuò)容的閾值
                sizeCtl = sc;
            }
            break;
        }
    }
    //數(shù)組已被初始化返回?cái)?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ù)組中第一個(gè)元素在內(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的個(gè)數(shù)
        //使用31減去包含0的個(gè)數(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ù)指定的索引位置計(jì)算該索引中的節(jié)點(diǎn)在內(nèi)存中的偏移量
    //并從tab數(shù)組中根據(jù)索引所在的內(nèi)存的偏移量獲取節(jié)點(diǎn)
    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ù)指定的索引位置計(jì)算該索引中的節(jié)點(diǎn)在內(nèi)存中的偏移量
    //并根據(jù)偏移量獲取節(jié)點(diǎn),并將獲取到的節(jié)點(diǎn)與傳遞的節(jié)點(diǎn)c進(jìn)行比較
    //如果兩個(gè)節(jié)點(diǎn)相同則使用節(jié)點(diǎn)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é)點(diǎn)正在轉(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 校驗(yàn)擴(kuò)容標(biāo)識(shí)是否一致,不一致則說明不是同一個(gè)數(shù)組
            //sc == rs + 1 應(yīng)該是sc == (rs << 16) + 1 校驗(yàn)擴(kuò)容是否完成
            //sc == rs + MAX_RESIZERS 應(yīng)該是sc == (rs << 16) + MAX_RESIZERS 校驗(yàn)擴(kuò)容的線程的數(shù)量是否到達(dá)最大
            //transferIndex <= 0 舊數(shù)組中還有多少?zèng)]有轉(zhuǎn)移的索引節(jié)點(diǎn)長度,如果小于等于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ù)組,對(duì)新的數(shù)組進(jìn)行操作
        return nextTab;
    }
    //當(dāng)前節(jié)點(diǎn)還未被轉(zhuǎn)移或新的數(shù)組還沒有被初始化則對(duì)舊數(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é)點(diǎn)設(shè)置為鏈表的頭節(jié)點(diǎn)
                f.prev = x;
            if (dir <= 0)
                xp.left = x;
            else
                xp.right = x;
            if (!xp.red)
                x.red = true;
            else {
                //獲取寫鎖,如果獲取寫鎖失敗則會(huì)將當(dāng)前線程掛起進(jìn)行等待
                //如果有線程正在讀,那當(dāng)前寫的線程就要掛起進(jìn)行等待
                //當(dāng)讀的線程執(zhí)行完成之后就會(huì)去喚醒掛起的線程
                //如果說當(dāng)前線程在寫,有線程準(zhǔn)備讀
                //那讀線程并不會(huì)去讀取紅黑樹中的節(jié)點(diǎn)
                //而是讀取鏈表的節(jié)點(diǎn),因?yàn)門reeBin對(duì)象中包含了紅黑樹的根節(jié)點(diǎn)并且也包含了鏈表的頭節(jié)點(diǎn)
                //如果發(fā)生寫寫的問題呢?
                //其實(shí)并不會(huì)發(fā)生寫寫的問題,因?yàn)楫?dāng)前整個(gè)方法都被外部的synchronized鎖住了
                lockRoot();
                try {
                    //平衡紅黑樹中的節(jié)點(diǎn)
                    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)前沒有線程對(duì)當(dāng)前TreeBin對(duì)象下的紅黑樹進(jìn)行加鎖
         * 不等于則說明有線程對(duì)TreeBin對(duì)象下的紅黑樹加鎖
         */
        if (((s = lockState) & ~WAITER) == 0) {
            //沒有線程對(duì)TreeBin對(duì)象下的紅黑樹加鎖
            //當(dāng)前線程則可以對(duì)TreeBin對(duì)象下的紅黑樹嘗試加鎖
            if (U.compareAndSwapInt(this, LOCKSTATE, s, WRITER)) {
                if (waiting)
                    //將等待線程清空
                    waiter = null;
                return;
            }
        //(s & WAITER) == 0 執(zhí)行當(dāng)前判斷語句的時(shí)候則說明有線程對(duì)紅黑樹加了鎖
        //如果(s & WAITER)等于0則說明沒有線程在等待加鎖
        //此時(shí)當(dāng)前線程就可以進(jìn)行等待
        } else if ((s & WAITER) == 0) {
            //將鎖狀態(tài)的32位二進(jìn)制中的第2位設(shè)置為1
            //代表當(dāng)前有一個(gè)線程正在等待加鎖
            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)了,此時(shí)就需要將線程掛起
            LockSupport.park(this);
    }
}

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

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

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

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

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