Java7/8中的HashMap和ConcurrentHashMap全解析

1. Java7中的HashMap（key，value均可以為空）：

大方向上HashMap是一個數組，每個數組元素是一個單向鏈表。

上圖中每個綠色的實體是嵌套類Entry的實例，Entry包含4個屬性：key，value，hash，和單鏈表的next。

capacity：數組的容量，始終保持在2^n，每次擴容后大小為擴容前的2倍。

loadfactor：擴容因子，始終保持在0.75。

threshold：擴容的閾值，大小為：capacity*loadfactor。

 

1.1put方法的過程：

總結：

當第一次插入時需要初始化數組的大小（threshold）；

判斷如果key為空就將這個Entry放入到table[ 0 ]中；

否則計算key的hash值，遍歷單鏈表，若該位置已有元素，就進行覆蓋，並返回舊值；

若不存在重復的值，就將該Entry放入到鏈表中。

public V put(K key, V value) {
    // 當插入第一個元素的時候，需要先初始化數組大小
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    // 如果 key 為 null，感興趣的可以往里看，最終會將這個 entry 放到 table[0] 中
    if (key == null)
        return putForNullKey(value);
    // 1. 求 key 的 hash 值
    int hash = hash(key);
    // 2. 找到對應的數組下標
    int i = indexFor(hash, table.length);
    // 3. 遍歷一下對應下標處的鏈表，看是否有重復的 key 已經存在，
    //    如果有，直接覆蓋，put 方法返回舊值就結束了
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    // 4. 不存在重復的 key，將此 entry 添加到鏈表中，細節后面說
    addEntry(hash, key, value, i);
    return null;
}

1.2數組（大小）的初始化：

當第一個數組元素放入HashMap時，就進行一次數組的初始化，就是先計算數組的大小，再計算閾值（threshold），並始終將數組內元素的數量保持在2^n個。

private void inflateTable(int toSize) {
    // 保證數組大小一定是 2 的 n 次方。
    // 比如這樣初始化：new HashMap(20)，那么處理成初始數組大小是 32
    int capacity = roundUpToPowerOf2(toSize);
    // 計算擴容閾值：capacity * loadFactor
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    // 算是初始化數組吧
    table = new Entry[capacity];
    initHashSeedAsNeeded(capacity); //ignore
10 }

1.3計算數組的位置：

根據key的Hash值，來對數組長度進行取模。eg：當數組長度為32時，可以取key的hash值的后5位，來進行計算相應數組中位置。

1.4添加結點到鏈表中：

找到數組下標后，進行key判重，若沒有重復，就將該元素放到鏈表的表頭位置。

以下方法首先判斷是否需要擴容，如果擴容后，就將元素放到相應數組位置上鏈表的表頭處。

void addEntry(int hash, K key, V value, int bucketIndex) {
    // 如果當前 HashMap 大小已經達到了閾值，並且新值要插入的數組位置已經有元素了，那么要擴容
    if ((size >= threshold) && (null != table[bucketIndex])) {
        // 擴容，后面會介紹一下
        resize(2 * table.length);
        // 擴容以后，重新計算 hash 值
        hash = (null != key) ? hash(key) : 0;
        // 重新計算擴容后的新的下標
        bucketIndex = indexFor(hash, table.length);
    }
    // 往下看
    createEntry(hash, key, value, bucketIndex);
}
// 這個很簡單，其實就是將新值放到鏈表的表頭，然后 size++
void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}

1.5數組的擴容：

擴容就是將小數組擴大成大數組再將元素轉移到大數組中。雙倍擴容：比如原數組（每個數組中放的其實是一個鏈表）中old [ i]的元素，會放到新數組的new [ i] ,和new [ i+oldlength]的位置上。

void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }
    // 新的數組
    Entry[] newTable = new Entry[newCapacity];
    // 將原來數組中的值遷移到新的更大的數組中
    transfer(newTable, initHashSeedAsNeeded(newCapacity));
    table = newTable;
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

1.6 get過程的分析:

 首先根據key計算hash值；

找到相應的數組下標 hash&（length-1）；

遍歷數組該位置的鏈表，直到找到相等（==或者equals）的key。

public V get(Object key) {
    // 之前說過，key 為 null 的話，會被放到 table[0]，所以只要遍歷下 table[0] 處的鏈表就可以了
    if (key == null)
        return getForNullKey();
    // 
    Entry<K,V> entry = getEntry(key);

    return null == entry ? null : entry.getValue();
}

getEntry（key）：

final Entry<K,V> getEntry(Object key) {
    if (size == 0) {
        //如果數組為空返回null
        return null;
    }
     //根據key計算hash值，通過hash值來判斷數組中的下標位置
    int hash = (key == null) ? 0 : hash(key);
    //確定數組下標后，遍歷該條鏈表直到找到（== / equals）為止
    for (Entry<K,V> e = table[indexFor(hash, table.length)];
         e != null;
         e = e.next) {
        Object k;
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            return e;
    }
    return null;
}

2.Java7的concurrentHashMap（value不能為空）：

concurrentHashMap支持並發操作，所以比HashMap復雜一點。concurrentHashMap采用分段鎖機制實現線程的同步，concurrentHasMap是由一個個個段組成。

如下圖所示：一個concurrentHashMap是由segment數組構成的，segment繼承了ReentrantLock來實現線程安全，所以只要保證了每個segment的安全性就實現了concurrentHashMap的線程安全。

 

 2.1初始化：

initialCapacity：初始容量，是ConcurrentHashMap的（"HashMap的數量"），會平均分給segment；

loadfactor：加載因子，ConcurrentHashMap不可擴容，所以加載因子是給每個segment用的；

concurrenceLevel：可以理解為：並發級別，並發數，segment數，默認值是16，表示一個concurrentHashMap有16個segment，即就是可以允許16個線程來同時寫，concurrenceLevel在初始化時可以指定大小，一旦初始化后不可擴容。（每個segment結構上很像HashMap）；

 

初始化完成后（調用new ConcurrentHashMap）：

segment數組的默認打小為16；

segment [ i ]的大小為2，加載因子是0.75，所以閾值為1.5，也就是說，當插入第一個元素時，不會擴容，第二個元素時segment[ i ] 會擴容;

並且初始了segment[ 0 ]，其他的位置還是null; 

 

public ConcurrentHashMap(int initialCapacity,
                         float loadFactor, int concurrencyLevel) {
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
        throw new IllegalArgumentException();
    if (concurrencyLevel > MAX_SEGMENTS)
        concurrencyLevel = MAX_SEGMENTS;
    // Find power-of-two sizes best matching arguments
    int sshift = 0;
    int ssize = 1;
    // 計算並行級別 ssize，因為要保持並行級別是 2 的 n 次方
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
    // 我們這里先不要那么燒腦，用默認值，concurrencyLevel 為 16，sshift 為 4
    // 那么計算出 segmentShift 為 28，segmentMask 為 15，后面會用到這兩個值
    this.segmentShift = 32 - sshift;
    this.segmentMask = ssize - 1;

    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;

    // initialCapacity 是設置整個 map 初始的大小，
    // 這里根據 initialCapacity 計算 Segment 數組中每個位置可以分到的大小
    // 如 initialCapacity 為 64，那么每個 Segment 或稱之為"槽"可以分到 4 個
    int c = initialCapacity / ssize;
    if (c * ssize < initialCapacity)
        ++c;
    // 默認 MIN_SEGMENT_TABLE_CAPACITY 是 2，這個值也是有講究的，因為這樣的話，對於具體的槽上，
    // 插入一個元素不至於擴容，插入第二個的時候才會擴容
    int cap = MIN_SEGMENT_TABLE_CAPACITY; 
    while (cap < c)
        cap <<= 1;

    // 創建 Segment 數組，
    // 並創建數組的第一個元素 segment[0]
    Segment<K,V> s0 =
        new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                         (HashEntry<K,V>[])new HashEntry[cap]);
    Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
    // 往數組寫入 segment[0]
    UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
    this.segments = ss;
}

2.2put的過程分析：

主流程：

public V put(K key, V value) {
    Segment<K,V> s;
    if (value == null)
        throw new NullPointerException();
    // 1. 計算 key 的 hash 值
    int hash = hash(key);
    // 2. 根據 hash 值找到 Segment 數組中的位置 j
    //    hash 是 32 位，無符號右移 segmentShift(28) 位，剩下高 4 位，
    //    然后和 segmentMask(15) 做一次與操作，也就是說 j 是 hash 值的高 4 位，也就是槽的數組下標
    int j = (hash >>> segmentShift) & segmentMask;
    // 剛剛說了，初始化的時候初始化了 segment[0]，但是其他位置還是 null，
    // ensureSegment(j) 對 segment[j] 進行初始化
    if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
         (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
        s = ensureSegment(j);
    // 3. 插入新值到 槽 s 中
    return s.put(key, hash, value, false);
}

 

根據key來計算hash的值，對應到segment數組的位置，再對segment[ i ]內部進行put操作，segment[ i ]的內部是一個數組+鏈表的形式。 

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
    // 在往該 segment 寫入前，需要先獲取該 segment 的獨占鎖
    //    先看主流程，后面還會具體介紹這部分內容
    HashEntry<K,V> node = tryLock() ? null :
        scanAndLockForPut(key, hash, value);
    V oldValue;
    try {
        // 這個是 segment 內部的數組
        HashEntry<K,V>[] tab = table;
        // 再利用 hash 值，求應該放置的數組下標
        int index = (tab.length - 1) & hash;
        // first 是數組該位置處的鏈表的表頭
        HashEntry<K,V> first = entryAt(tab, index);

        // 下面這串 for 循環雖然很長，不過也很好理解，想想該位置沒有任何元素和已經存在一個鏈表這兩種情況
        for (HashEntry<K,V> e = first;;) {
            if (e != null) {
                K k;
                if ((k = e.key) == key ||
                    (e.hash == hash && key.equals(k))) {
                    oldValue = e.value;
                    if (!onlyIfAbsent) {
                        // 覆蓋舊值
                        e.value = value;
                        ++modCount;
                    }
                    break;
                }
                // 繼續順着鏈表走
                e = e.next;
            }
            else {
                // node 到底是不是 null，這個要看獲取鎖的過程，不過和這里都沒有關系。
                // 如果不為 null，那就直接將它設置為鏈表表頭；如果是null，初始化並設置為鏈表表頭。
                if (node != null)
                    node.setNext(first);
                else
                    node = new HashEntry<K,V>(hash, key, value, first);

                int c = count + 1;
                // 如果超過了該 segment 的閾值，這個 segment 需要擴容
                if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                    rehash(node); // 擴容后面也會具體分析
                else
                    // 沒有達到閾值，將 node 放到數組 tab 的 index 位置，
                    // 其實就是將新的節點設置成原鏈表的表頭
                    setEntryAt(tab, index, node);
                ++modCount;
                count = c;
                oldValue = null;
                break;
            }
        }
    } finally {
        // 解鎖
        unlock();
    }
    return oldValue;
}

put操作中的關鍵幾步：

初始化段 （ensuresegment）：

ConcurrentHashMap初始化時只初始化了第一個segment[ 0 ]，其他的segment[ j ]，在放第一個元素時進行初始化；當有多個線程進來初始化同一個segment[ i ]時，只會有一個初始化成功（對於並發操作采用CAS算法進行控制該初始化操作）。 

private Segment<K,V> ensureSegment(int k) {
    final Segment<K,V>[] ss = this.segments;
    long u = (k << SSHIFT) + SBASE; // raw offset
    Segment<K,V> seg;
    if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
        // 這里看到為什么之前要初始化 segment[0] 了，
        // 使用當前 segment[0] 處的數組長度和負載因子來初始化 segment[k]
        // 為什么要用“當前”，因為 segment[0] 可能早就擴容過了
        Segment<K,V> proto = ss[0];
        int cap = proto.table.length;
        float lf = proto.loadFactor;
        int threshold = (int)(cap * lf);

        // 初始化 segment[k] 內部的數組
        HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry[cap];
        if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
            == null) { // 再次檢查一遍該槽是否被其他線程初始化了。

            Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
            // 使用 while 循環，內部用 CAS，當前線程成功設值或其他線程成功設值后，退出
            while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
                   == null) {
                if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
                    break;
            }
        }
    }
    return seg;
}

獲取寫入鎖（scanAndlockForPut）：

在每次寫入到segment前會調用：node = tyrLock（）？null ：scanAndLockForput（key，value，hash），即首先會進行tryLock（）來獲取segment的獨占鎖，若獲取失敗就調用scanAndLockforput（key，value，hash）來獲取鎖。

scanAndLockForPut（key，value，hash）實現控制加鎖：

此方法有兩個出口：

一個是tryLock（）成功了退出循環，否則當循環超過一定次數，就會調用lock（）--->進入到阻塞等待，直到tryLock（）成功！

該方法主要是獲取segment的獨占鎖。

private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
    HashEntry<K,V> first = entryForHash(this, hash);
    HashEntry<K,V> e = first;
    HashEntry<K,V> node = null;
    int retries = -1; // negative while locating node

    // 循環獲取鎖
    while (!tryLock()) {
        HashEntry<K,V> f; // to recheck first below
        if (retries < 0) {
            if (e == null) {
                if (node == null) // speculatively create node
                    // 進到這里說明數組該位置的鏈表是空的，沒有任何元素
                    // 當然，進到這里的另一個原因是 tryLock() 失敗，所以該槽存在並發，不一定是該位置
                    node = new HashEntry<K,V>(hash, key, value, null);
                retries = 0;
            }
            else if (key.equals(e.key))
                retries = 0;
            else
                // 順着鏈表往下走
                e = e.next;
        }
        // 重試次數如果超過 MAX_SCAN_RETRIES（單核1多核64），那么不搶了，進入到阻塞隊列等待鎖
        //    lock() 是阻塞方法，直到獲取鎖后返回
        else if (++retries > MAX_SCAN_RETRIES) {
            lock();
            break;
        }
        else if ((retries & 1) == 0 &&
                 // 這個時候是有大問題了，那就是有新的元素進到了鏈表，成為了新的表頭
                 //     所以這邊的策略是，相當於重新走一遍這個 scanAndLockForPut 方法
                 (f = entryForHash(this, hash)) != first) {
            e = first = f; // re-traverse if entry changed
            retries = -1;
        }
    }
    return node;
}

擴容：rehash

需要注意：segment數組不會擴容，只是對segment數組某一位置上的內部數組（HashEntry <key，value> [ ]）進行擴容操作，擴容后的容量為原容量的2倍。在put前會判斷該元素的插入會導致數組元素超過閾值？ 如果是，就先擴容(2倍大小)再插入。

以下的方法不需要考慮並發，因為此時還持有segment的獨占鎖。

（也是會將old[ i ]位置上的元素放到new[ i ]和new[ i+old.length]）

// 方法參數上的 node 是這次擴容后，需要添加到新的數組中的數據。
private void rehash(HashEntry<K,V> node) {
    HashEntry<K,V>[] oldTable = table;
    int oldCapacity = oldTable.length;
    // 2 倍
    int newCapacity = oldCapacity << 1;
    threshold = (int)(newCapacity * loadFactor);
    // 創建新數組
    HashEntry<K,V>[] newTable =
        (HashEntry<K,V>[]) new HashEntry[newCapacity];
    // 新的掩碼，如從 16 擴容到 32，那么 sizeMask 為 31，對應二進制 ‘000...00011111’
    int sizeMask = newCapacity - 1;

    // 遍歷原數組，老套路，將原數組位置 i 處的鏈表拆分到 新數組位置 i 和 i+oldCap 兩個位置
    for (int i = 0; i < oldCapacity ; i++) {
        // e 是鏈表的第一個元素
        HashEntry<K,V> e = oldTable[i];
        if (e != null) {
            HashEntry<K,V> next = e.next;
            // 計算應該放置在新數組中的位置，
            // 假設原數組長度為 16，e 在 oldTable[3] 處，那么 idx 只可能是 3 或者是 3 + 16 = 19
            int idx = e.hash & sizeMask;
            if (next == null)   // 該位置處只有一個元素，那比較好辦
                newTable[idx] = e;
            else { // Reuse consecutive sequence at same slot
                // e 是鏈表表頭
                HashEntry<K,V> lastRun = e;
                // idx 是當前鏈表的頭結點 e 的新位置
                int lastIdx = idx;

                // 下面這個 for 循環會找到一個 lastRun 節點，這個節點之后的所有元素是將要放到一起的
                for (HashEntry<K,V> last = next;
                     last != null;
                     last = last.next) {
                    int k = last.hash & sizeMask;
                    if (k != lastIdx) {
                        lastIdx = k;
                        lastRun = last;
                    }
                }
                // 將 lastRun 及其之后的所有節點組成的這個鏈表放到 lastIdx 這個位置
                newTable[lastIdx] = lastRun;
                // 下面的操作是處理 lastRun 之前的節點，
                //    這些節點可能分配在另一個鏈表中，也可能分配到上面的那個鏈表中
                for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
                    V v = p.value;
                    int h = p.hash;
                    int k = h & sizeMask;
                    HashEntry<K,V> n = newTable[k];
                    newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
                }
            }
        }
    }
    // 將新來的 node 放到新數組中剛剛的 兩個鏈表之一 的 頭部
    int nodeIndex = node.hash & sizeMask; // add the new node
    node.setNext(newTable[nodeIndex]);
    newTable[nodeIndex] = node;
    table = newTable;
}

2.3get的過程分析：

根據key計算Hash值；

依據Hash值定位到segment[ i ];

依據Hash值定位到segment[ i ]的內部數組（HashEntry<k,v>[ ]）中的某一位置處;

遍歷該數組處的鏈表。

public V get(Object key) {
    Segment<K,V> s; // manually integrate access methods to reduce overhead
    HashEntry<K,V>[] tab;
    // 1. hash 值
    int h = hash(key);
    long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
    // 2. 根據 hash 找到對應的 segment
    if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
        (tab = s.table) != null) {
        // 3. 找到segment 內部數組相應位置的鏈表，遍歷
        for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                 (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
             e != null; e = e.next) {
            K k;
            if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                return e.value;
        }
    }
    return null;
}

2.x並發問題的分析：

get操作是沒有進行加鎖的，添加元素put和刪除元素remove都需要獲取segment的獨占鎖，

這里需要考慮的是在get的過程中遇到put和remove時：

put操作的線程安全性：

初始化段：segment的初始化采用了CAS算法來實現並發控制；

添加結點到鏈表操作是添加到鏈表表頭的；

 3.Java8的HashMap：

Java8對HashMap做了一些修改，最大的不同就是使用了紅黑樹，所以是由（數組，鏈表，紅黑樹）組成的。

在Java7中，當在鏈表中查找目標元素時，時間復雜度是由鏈表長度決定的，為O (n)，為了減少這部分的開銷，

zaiJava8中，當鏈表長度達到8時，就將鏈表轉化成紅黑樹的結構，可以降低時間復雜度為O(logN)。

在Java7中使用Entry來存儲HashMap的元素，Java8中采用Node，不過Entry和Node都包含了key，value，hash，next這幾個屬性，Node是適用於鏈表的，TreeNode是紅黑樹。

所以我們可以根據Node和TreeNode來判斷是鏈表還是紅黑樹。

3.1put過程分析：

第一次進行put操作時，會調用resize（），類似於Java7的初始化數組的大小，即從null初始化到16或者指定的大小；

根據key的Hash值來定位到數組的某一位置Node[ i ] ，

若數組該位置沒有元素時就初始化Node，將Node放到鏈表頭部（通過key計算的hash值相同時會將value放到數組的同一位置處，形成鏈表）；

若數組的該位置已有元素就比較key的equals()，若equals為true，則進行覆蓋，否則就將該Node放到鏈表的后面，若是樹結構，就調用樹的put；

當插入的元素是鏈表的第八個元素時，就將鏈表轉換成紅黑樹。

 

與Java7的不同：

在擴容時：先插入，再擴容；

當鏈表長度達到8時，就轉為紅黑樹。

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

// 第三個參數 onlyIfAbsent 如果是 true，那么只有在不存在該 key 時才會進行 put 操作
// 第四個參數 evict 我們這里不關心
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // 第一次 put 值的時候，會觸發下面的 resize()，類似 java7 的第一次 put 也要初始化數組長度
    // 第一次 resize 和后續的擴容有些不一樣，因為這次是數組從 null 初始化到默認的 16 或自定義的初始容量
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 找到具體的數組下標，如果此位置沒有值，那么直接初始化一下 Node 並放置在這個位置就可以了
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);

    else {// 數組該位置有數據
        Node<K,V> e; K k;
        // 首先，判斷該位置的第一個數據和我們要插入的數據，key 是不是"相等"，如果是，取出這個節點
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 如果該節點是代表紅黑樹的節點，調用紅黑樹的插值方法，本文不展開說紅黑樹
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 到這里，說明數組該位置上是一個鏈表
            for (int binCount = 0; ; ++binCount) {
                // 插入到鏈表的最后面(Java7 是插入到鏈表的最前面)
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // TREEIFY_THRESHOLD 為 8，所以，如果新插入的值是鏈表中的第 8 個
                    // 會觸發下面的 treeifyBin，也就是將鏈表轉換為紅黑樹
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                // 如果在該鏈表中找到了"相等"的 key(== 或 equals)
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 此時 break，那么 e 為鏈表中[與要插入的新值的 key "相等"]的 node
                    break;
                p = e;
            }
        }
        // e!=null 說明存在舊值的key與要插入的key"相等"
        // 對於我們分析的put操作，下面這個 if 其實就是進行 "值覆蓋"，然后返回舊值
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // 如果 HashMap 由於新插入這個值導致 size 已經超過了閾值，需要進行擴容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

3.2數組擴容：

resize（）用來進行數組的初始化，或者擴容，每次擴容后大小為原來的2倍，並進行數據的轉移。

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) { // 對應數組擴容
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 將數組大小擴大一倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            // 將閾值擴大一倍
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // 對應使用 new HashMap(int initialCapacity) 初始化后，第一次 put 的時候
        newCap = oldThr;
    else {// 對應使用 new HashMap() 初始化后，第一次 put 的時候
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }

    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;

    // 用新的數組大小初始化新的數組
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab; // 如果是初始化數組，到這里就結束了，返回 newTab 即可

    if (oldTab != null) {
        // 開始遍歷原數組，進行數據遷移。
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                // 如果該數組位置上只有單個元素，那就簡單了，簡單遷移這個元素就可以了
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                // 如果是紅黑樹，具體我們就不展開了
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { 
                    // 這塊是處理鏈表的情況，
                    // 需要將此鏈表拆成兩個鏈表，放到新的數組中，並且保留原來的先后順序
                    // loHead、loTail 對應一條鏈表，hiHead、hiTail 對應另一條鏈表，代碼還是比較簡單的
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        // 第一條鏈表
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        // 第二條鏈表的新的位置是 j + oldCap，這個很好理解
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

 3.3get過程解析：

首先根據key計算hash值，定位到數組的某一位置；

檢查數組該位置處的第一個元素是不是需要get的，不是就進行下一步；

若數組下是紅黑樹結構，就調用樹的方法來取元素；

否則就進行遍歷鏈表，直到找到key的相等（==或者equals（））；

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}


final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 判斷第一個節點是不是就是需要的
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            // 判斷是否是紅黑樹
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);

            // 鏈表遍歷
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

4.Java8的ConcurrentHashMap：

4.1初始化：

無參構造方法：

// 這構造函數里，什么都不干
public ConcurrentHashMap() {
}

public ConcurrentHashMap(int initialCapacity) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException();
    int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
               MAXIMUM_CAPACITY :
               tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
    this.sizeCtl = cap;
}

通過提供的初始容量，計算sizeCtl=(【1.1*initialCapacity+1】，再向上取最近的2^n)。

4.2put的過程分析：

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



final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    // 得到 hash 值
    int hash = spread(key.hashCode());
    // 用於記錄相應鏈表的長度
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        // 如果數組"空"，進行數組初始化
        if (tab == null || (n = tab.length) == 0)
            // 初始化數組，后面會詳細介紹
            tab = initTable();

        // 找該 hash 值對應的數組下標，得到第一個節點 f
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // 如果數組該位置為空，
            //    用一次 CAS 操作將這個新值放入其中即可，這個 put 操作差不多就結束了，可以拉到最后面了
            //          如果 CAS 失敗，那就是有並發操作，進到下一個循環就好了
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        // hash 居然可以等於 MOVED，這個需要到后面才能看明白，不過從名字上也能猜到，肯定是因為在擴容
        else if ((fh = f.hash) == MOVED)
            // 幫助數據遷移，這個等到看完數據遷移部分的介紹后，再理解這個就很簡單了
            tab = helpTransfer(tab, f);

        else { // 到這里就是說，f 是該位置的頭結點，而且不為空

            V oldVal = null;
            // 獲取數組該位置的頭結點的監視器鎖
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) { // 頭結點的 hash 值大於 0，說明是鏈表
                        // 用於累加，記錄鏈表的長度
                        binCount = 1;
                        // 遍歷鏈表
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            // 如果發現了"相等"的 key，判斷是否要進行值覆蓋，然后也就可以 break 了
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            // 到了鏈表的最末端，將這個新值放到鏈表的最后面
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) { // 紅黑樹
                        Node<K,V> p;
                        binCount = 2;
                        // 調用紅黑樹的插值方法插入新節點
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                       value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }

            if (binCount != 0) {
                // 判斷是否要將鏈表轉換為紅黑樹，臨界值和 HashMap 一樣，也是 8
                if (binCount >= TREEIFY_THRESHOLD)
                    // 這個方法和 HashMap 中稍微有一點點不同，那就是它不是一定會進行紅黑樹轉換，
                    // 如果當前數組的長度小於 64，那么會選擇進行數組擴容，而不是轉換為紅黑樹
                    //    具體源碼我們就不看了，擴容部分后面說
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 
    addCount(1L, binCount);
    return null;
}

流程的大概總結：

首先計算key的hash值，定位到數組的某一位置上；

若該數組為空，就進行數組的初始化initTable（）；

若數組不為空，找到hash值對應的數組下標，並返回第一個結點，若數組的該位置為空，就采用CAS操作將新元素放入到，該位置上put方法就可以宣告結束了。若CAS操作失敗，說明有並發操作，等待下一次的循環就好；

若數該位置處的首元素的hash值為（"MOVED"），說明數組正在擴容，幫助數據遷移helpTransfer（）；

當數組該位置處的頭結點不為空，也不進行擴容時：獲取數組該位置處頭結點的監視器鎖，若頭結點的hash值>0,說明是鏈表結構，遍歷鏈表，看是否需要進行覆蓋，否則就在鏈表的末尾處插入新值；否則為樹結構，調用putTreeval方法插入新值。

若是鏈表結構，再進行判斷是否需要轉換成紅黑樹。

put主要操作的介紹：

初始化數組：（initTable）

初始化一個合適大小的數組，再設置sizeCtl，通過sizeCtl控制CAS操作。

若sizeCtl的值<0，說明有其他線程正在初始化；

否則采用CAS操作進行數組的初始化，將sizeCtl的值設為-1，說明搶到了鎖；

初始化數組，長度為16，或者提供的長度，將這個數組賦值給table，table是Volatile的；

設置sizeCtl的值為sc。

private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        // 初始化的"功勞"被其他線程"搶去"了
        if ((sc = sizeCtl) < 0)
            Thread.yield(); // lost initialization race; just spin
        // CAS 一下，將 sizeCtl 設置為 -1，代表搶到了鎖
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                if ((tab = table) == null || tab.length == 0) {
                    // DEFAULT_CAPACITY 默認初始容量是 16
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    // 初始化數組，長度為 16 或初始化時提供的長度
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    // 將這個數組賦值給 table，table 是 volatile 的
                    table = tab = nt;
                    // 如果 n 為 16 的話，那么這里 sc = 12
                    // 其實就是 0.75 * n
                    sc = n - (n >>> 2);
                }
            } finally {
                // 設置 sizeCtl 為 sc，我們就當是 12 吧
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

鏈表轉紅黑樹：（treeifyBin）

treeifyBin不一定進行紅黑樹的轉換，也可能只是數組的擴容。轉換前先計算鏈表的長度，若長度小於限定值64 ，就只進行擴容操作，否則轉紅黑樹。

private final void treeifyBin(Node<K,V>[] tab, int index) {
    Node<K,V> b; int n, sc;
    if (tab != null) {
        // MIN_TREEIFY_CAPACITY 為 64
        // 所以，如果數組長度小於 64 的時候，其實也就是 32 或者 16 或者更小的時候，會進行數組擴容
        if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
            // 后面我們再詳細分析這個方法
            tryPresize(n << 1);
        // b 是頭結點
        else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
            // 加鎖
            synchronized (b) {

                if (tabAt(tab, index) == b) {
                    // 下面就是遍歷鏈表，建立一顆紅黑樹
                    TreeNode<K,V> hd = null, tl = null;
                    for (Node<K,V> e = b; e != null; e = e.next) {
                        TreeNode<K,V> p =
                            new TreeNode<K,V>(e.hash, e.key, e.val,
                                              null, null);
                        if ((p.prev = tl) == null)
                            hd = p;
                        else
                            tl.next = p;
                        tl = p;
                    }
                    // 將紅黑樹設置到數組相應位置中
                    setTabAt(tab, index, new TreeBin<K,V>(hd));
                }
            }
        }
    }
}

擴容：（tryPresize）

擴大容量為原先的2倍。

// 首先要說明的是，方法參數 size 傳進來的時候就已經翻了倍了
private final void tryPresize(int size) {
    // c：size 的 1.5 倍，再加 1，再往上取最近的 2 的 n 次方。
    int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
        tableSizeFor(size + (size >>> 1) + 1);
    int sc;
    while ((sc = sizeCtl) >= 0) {
        Node<K,V>[] tab = table; int n;

        // 這個 if 分支和之前說的初始化數組的代碼基本上是一樣的，在這里，我們可以不用管這塊代碼
        if (tab == null || (n = tab.length) == 0) {
            n = (sc > c) ? sc : c;
            if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    if (table == tab) {
                        @SuppressWarnings("unchecked")
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        table = nt;
                        sc = n - (n >>> 2); // 0.75 * n
                    }
                } finally {
                    sizeCtl = sc;
                }
            }
        }
        else if (c <= sc || n >= MAXIMUM_CAPACITY)
            break;
        else if (tab == table) {
            // 我沒看懂 rs 的真正含義是什么，不過也關系不大
            int rs = resizeStamp(n);

            if (sc < 0) {
                Node<K,V>[] nt;
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                    transferIndex <= 0)
                    break;
                // 2. 用 CAS 將 sizeCtl 加 1，然后執行 transfer 方法
                //    此時 nextTab 不為 null
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            // 1. 將 sizeCtl 設置為 (rs << RESIZE_STAMP_SHIFT) + 2)
            //     我是沒看懂這個值真正的意義是什么？不過可以計算出來的是，結果是一個比較大的負數
            //  調用 transfer 方法，此時 nextTab 參數為 null
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
        }
    }
}

數據的遷移：（transfer）

下面這個方法有點長，將原來的 tab 數組的元素遷移到新的 nextTab 數組中。

雖然我們之前說的 tryPresize 方法中多次調用 transfer 不涉及多線程，但是這個 transfer 方法可以在其他地方被調用，典型地，我們之前在說 put 方法的時候就說過了，請往上看 put 方法，是不是有個地方調用了 helpTransfer 方法，helpTransfer 方法會調用 transfer 方法的。

此方法支持多線程執行，外圍調用此方法的時候，會保證第一個發起數據遷移的線程，nextTab 參數為 null，之后再調用此方法的時候，nextTab 不會為 null。

閱讀源碼之前，先要理解並發操作的機制。原數組長度為 n，所以我們有 n 個遷移任務，讓每個線程每次負責一個小任務是最簡單的，每做完一個任務再檢測是否有其他沒做完的任務，幫助遷移就可以了，而 Doug Lea 使用了一個 stride，簡單理解就是步長，每個線程每次負責遷移其中的一部分，如每次遷移 16 個小任務。所以，我們就需要一個全局的調度者來安排哪個線程執行哪幾個任務，這個就是屬性 transferIndex 的作用。

第一個發起數據遷移的線程會將 transferIndex 指向原數組最后的位置，然后從后往前的 stride 個任務屬於第一個線程，然后將 transferIndex 指向新的位置，再往前的 stride 個任務屬於第二個線程，依此類推。當然，這里說的第二個線程不是真的一定指代了第二個線程，也可以是同一個線程，這個讀者應該能理解吧。其實就是將一個大的遷移任務分為了一個個任務包。

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    int n = tab.length, stride;

    // stride 在單核下直接等於 n，多核模式下為 (n>>>3)/NCPU，最小值是 16
    // stride 可以理解為”步長“，有 n 個位置是需要進行遷移的，
    //   將這 n 個任務分為多個任務包，每個任務包有 stride 個任務
    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
        stride = MIN_TRANSFER_STRIDE; // subdivide range

    // 如果 nextTab 為 null，先進行一次初始化
    //    前面我們說了，外圍會保證第一個發起遷移的線程調用此方法時，參數 nextTab 為 null
    //       之后參與遷移的線程調用此方法時，nextTab 不會為 null
    if (nextTab == null) {
        try {
            // 容量翻倍
            Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
            nextTab = nt;
        } catch (Throwable ex) {      // try to cope with OOME
            sizeCtl = Integer.MAX_VALUE;
            return;
        }
        // nextTable 是 ConcurrentHashMap 中的屬性
        nextTable = nextTab;
        // transferIndex 也是 ConcurrentHashMap 的屬性，用於控制遷移的位置
        transferIndex = n;
    }

    int nextn = nextTab.length;

    // ForwardingNode 翻譯過來就是正在被遷移的 Node
    // 這個構造方法會生成一個Node，key、value 和 next 都為 null，關鍵是 hash 為 MOVED
    // 后面我們會看到，原數組中位置 i 處的節點完成遷移工作后，
    //    就會將位置 i 處設置為這個 ForwardingNode，用來告訴其他線程該位置已經處理過了
    //    所以它其實相當於是一個標志。
    ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);


    // advance 指的是做完了一個位置的遷移工作，可以准備做下一個位置的了
    boolean advance = true;
    boolean finishing = false; // to ensure sweep before committing nextTab

    /*
     * 下面這個 for 循環，最難理解的在前面，而要看懂它們，應該先看懂后面的，然后再倒回來看
     * 
     */

    // i 是位置索引，bound 是邊界，注意是從后往前
    for (int i = 0, bound = 0;;) {
        Node<K,V> f; int fh;

        // 下面這個 while 真的是不好理解
        // advance 為 true 表示可以進行下一個位置的遷移了
        //   簡單理解結局：i 指向了 transferIndex，bound 指向了 transferIndex-stride
        while (advance) {
            int nextIndex, nextBound;
            if (--i >= bound || finishing)
                advance = false;

            // 將 transferIndex 值賦給 nextIndex
            // 這里 transferIndex 一旦小於等於 0，說明原數組的所有位置都有相應的線程去處理了
            else if ((nextIndex = transferIndex) <= 0) {
                i = -1;
                advance = false;
            }
            else if (U.compareAndSwapInt
                     (this, TRANSFERINDEX, nextIndex,
                      nextBound = (nextIndex > stride ?
                                   nextIndex - stride : 0))) {
                // 看括號中的代碼，nextBound 是這次遷移任務的邊界，注意，是從后往前
                bound = nextBound;
                i = nextIndex - 1;
                advance = false;
            }
        }
        if (i < 0 || i >= n || i + n >= nextn) {
            int sc;
            if (finishing) {
                // 所有的遷移操作已經完成
                nextTable = null;
                // 將新的 nextTab 賦值給 table 屬性，完成遷移
                table = nextTab;
                // 重新計算 sizeCtl：n 是原數組長度，所以 sizeCtl 得出的值將是新數組長度的 0.75 倍
                sizeCtl = (n << 1) - (n >>> 1);
                return;
            }

            // 之前我們說過，sizeCtl 在遷移前會設置為 (rs << RESIZE_STAMP_SHIFT) + 2
            // 然后，每有一個線程參與遷移就會將 sizeCtl 加 1，
            // 這里使用 CAS 操作對 sizeCtl 進行減 1，代表做完了屬於自己的任務
            if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                // 任務結束，方法退出
                if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                    return;

                // 到這里，說明 (sc - 2) == resizeStamp(n) << RESIZE_STAMP_SHIFT，
                // 也就是說，所有的遷移任務都做完了，也就會進入到上面的 if(finishing){} 分支了
                finishing = advance = true;
                i = n; // recheck before commit
            }
        }
        // 如果位置 i 處是空的，沒有任何節點，那么放入剛剛初始化的 ForwardingNode ”空節點“
        else if ((f = tabAt(tab, i)) == null)
            advance = casTabAt(tab, i, null, fwd);
        // 該位置處是一個 ForwardingNode，代表該位置已經遷移過了
        else if ((fh = f.hash) == MOVED)
            advance = true; // already processed
        else {
            // 對數組該位置處的結點加鎖，開始處理數組該位置處的遷移工作
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    Node<K,V> ln, hn;
                    // 頭結點的 hash 大於 0，說明是鏈表的 Node 節點
                    if (fh >= 0) {
                        // 下面這一塊和 Java7 中的 ConcurrentHashMap 遷移是差不多的，
                        // 需要將鏈表一分為二，
                        //   找到原鏈表中的 lastRun，然后 lastRun 及其之后的節點是一起進行遷移的
                        //   lastRun 之前的節點需要進行克隆，然后分到兩個鏈表中
                        int runBit = fh & n;
                        Node<K,V> lastRun = f;
                        for (Node<K,V> p = f.next; p != null; p = p.next) {
                            int b = p.hash & n;
                            if (b != runBit) {
                                runBit = b;
                                lastRun = p;
                            }
                        }
                        if (runBit == 0) {
                            ln = lastRun;
                            hn = null;
                        }
                        else {
                            hn = lastRun;
                            ln = null;
                        }
                        for (Node<K,V> p = f; p != lastRun; p = p.next) {
                            int ph = p.hash; K pk = p.key; V pv = p.val;
                            if ((ph & n) == 0)
                                ln = new Node<K,V>(ph, pk, pv, ln);
                            else
                                hn = new Node<K,V>(ph, pk, pv, hn);
                        }
                        // 其中的一個鏈表放在新數組的位置 i
                        setTabAt(nextTab, i, ln);
                        // 另一個鏈表放在新數組的位置 i+n
                        setTabAt(nextTab, i + n, hn);
                        // 將原數組該位置處設置為 fwd，代表該位置已經處理完畢，
                        //    其他線程一旦看到該位置的 hash 值為 MOVED，就不會進行遷移了
                        setTabAt(tab, i, fwd);
                        // advance 設置為 true，代表該位置已經遷移完畢
                        advance = true;
                    }
                    else if (f instanceof TreeBin) {
                        // 紅黑樹的遷移
                        TreeBin<K,V> t = (TreeBin<K,V>)f;
                        TreeNode<K,V> lo = null, loTail = null;
                        TreeNode<K,V> hi = null, hiTail = null;
                        int lc = 0, hc = 0;
                        for (Node<K,V> e = t.first; e != null; e = e.next) {
                            int h = e.hash;
                            TreeNode<K,V> p = new TreeNode<K,V>
                                (h, e.key, e.val, null, null);
                            if ((h & n) == 0) {
                                if ((p.prev = loTail) == null)
                                    lo = p;
                                else
                                    loTail.next = p;
                                loTail = p;
                                ++lc;
                            }
                            else {
                                if ((p.prev = hiTail) == null)
                                    hi = p;
                                else
                                    hiTail.next = p;
                                hiTail = p;
                                ++hc;
                            }
                        }
                        // 如果一分為二后，節點數少於 8，那么將紅黑樹轉換回鏈表
                        ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                            (hc != 0) ? new TreeBin<K,V>(lo) : t;
                        hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                            (lc != 0) ? new TreeBin<K,V>(hi) : t;

                        // 將 ln 放置在新數組的位置 i
                        setTabAt(nextTab, i, ln);
                        // 將 hn 放置在新數組的位置 i+n
                        setTabAt(nextTab, i + n, hn);
                        // 將原數組該位置處設置為 fwd，代表該位置已經處理完畢，
                        //    其他線程一旦看到該位置的 hash 值為 MOVED，就不會進行遷移了
                        setTabAt(tab, i, fwd);
                        // advance 設置為 true，代表該位置已經遷移完畢
                        advance = true;
                    }
                }
            }
        }
    }
}

4.3get過程的分析：

計算key的hash值，根據hash值定位到數組的某一位置；

根據該位置處結點的性質進行查找：

若該位置為null，直接返回null；

若該位置處的結點是要get的，就返回該節點的值即可；

若該位置結點的hash值小於0，說明正在進行擴容，或者是樹結構；

否則，就是鏈表結構，直接進行對比key值即可。

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    int h = spread(key.hashCode());
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        // 判斷頭結點是否就是我們需要的節點
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        // 如果頭結點的 hash 小於 0，說明 正在擴容，或者該位置是紅黑樹
        else if (eh < 0)
            // 參考 ForwardingNode.find(int h, Object k) 和 TreeBin.find(int h, Object k)
            return (p = e.find(h, key)) != null ? p.val : null;

        // 遍歷鏈表
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}