HashMap原始碼解析、jdk7和8之後的區別、相關問題分析（多執行緒擴容帶來的死迴圈）
阿新 • • 發佈：2020-09-07
# 一、概覽
```java
HashMap map = new HashMap<>();
```
這個語句執行起來，在 jdk1.8 之前，會建立一個長度是 16 的 `Entry[]` 陣列，叫 `table`，用來儲存鍵值對。
在 jdk 1.8 後，不在這裡建立陣列了，而是在第一次 `put` 的時候才會建立陣列叫 `Node[] table` ，用來儲存鍵值對。
# 二、原始碼的成員變數分析
**宣告部分**：
[] tab; Node p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;//呼叫resize方法初始化tab，驗證了我們說的，構造方法不會建立陣列，而是插入的時候建立。
//這個演算法前面也已經講過，就是計算索引，如果p的位置是 null，就在這裡放入一個newNode；
//如果p的位置不是 null，說明這個桶裡已經有連結串列或者樹了，就不能直接 new ，而是要遍歷連結串列插入，並同時判斷是不是需要轉樹
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node e; K k;
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
//已經不是連結串列是紅黑樹了，呼叫putTreeVal
e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
else {
//是連結串列，用 for 迴圈遍歷
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;//如果已經有值，覆蓋，這裡用到了onlyIfAbsent
afterNodeAccess(e);
return oldValue;
}
}
//增加修改hashMap的次數
++modCount;
//如果已經達到了閾值，就要擴容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
```
這裡面涉及到的步驟主要如下：
1. 呼叫 `resize` 方法初始化 `table` 陣列，jdk1.8 後確實是到 `put` 的時候才會初始化陣列；
2. 用 `hash` 值計算出在數組裡應該在的索引；
3. 如果索引位置是 `null`，就直接放入一個新節點，也就是 `Node` 物件；
4. 如果不是 `null`，則要在這個桶裡插入：
1. 如果遇見了一個節點的 `hash` 值、key值和傳入的這個新的一樣，賦值給 `e` 這個節點；
2. 用 `instanceof` 判斷是否為 `TreeNode` 型別，也就是說如果這個桶裡已經不是連結串列而是紅黑樹了，就呼叫 `putTreeVal` 方法；
3. 如果不是，那就要遍歷這個連結串列，同理，遍歷的過程如果也找到了一個階段的 `hash` 值、`key` 值和傳入的一樣，賦值給 `e` 這個節點，否則遍歷到最後，把一個 `Node` 物件插到連結串列末尾，插完後連結串列長度已經大於閾值，就要轉樹。
5. 結束插入的動作後，前面的 `e` 一旦被賦值過了，說明是有一樣的 `key` 出現，那麼就說明不用插入新節點，而是替代舊的 `val`。
這裡面涉及到的 resize 、putTreeVal 和 treeifyBin 也是比較複雜的方法，下來進行介紹。
## 3.3 treeifyBin 方法
轉換為樹的方法
```java
final void treeifyBin(Node[] tab, int hash) {
int n, index; Node e;
//如果陣列的長度還沒有達到 64 ，就不轉樹，只是擴容。
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
//如果 e 不為空，那麼遍歷整個連結串列，把每個節點都換成具有prev和next兩個指標的樹節點
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode hd = null, tl = null;
do {
TreeNode p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
//結束後要開始把一個普通的樹（此時其實嚴格上說是一個雙鏈表的形態）轉化成紅黑樹
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
```
treeify 裡面呼叫了各種`左旋啊、右旋啊，平衡`啊，各種很複雜的紅黑樹操作方法，這裡不再深入。
## 3.4 resize 擴容方法
問題：什麼時候會擴容？
從前面成員變數的解釋和插入元素，已經能總結出兩種擴容的情況：
1. 當鍵值對的元素個數（也就是鍵值對的個數，size）超過了 `陣列長度*負載因子（0.75）`的時候，擴容；
2. 當其中某一個連結串列的元素個數達到 `8` 個，並且陣列長度沒有達到 `64` ，則擴容而不轉紅黑樹。
擴容每次都會把陣列的長度擴到 `2` 倍，並且之後還要把每個元素的下標重新計算，這樣的開銷是很大的。
值得注意的是，重新計算下標值的方法 和第一次的計算方法一樣，這樣很簡便且巧妙：
* 首先，仍然使用 `(n - 1) & hash` 這個式子計算索引，但是顯然有重新計算的時候，變化的是 `n-1`，有些就不會在原位置了；
* 從 `n` 的變化入手，因為是 `2` 倍擴容，而陣列長度本身也設定是 `2` 的冪次，在二進位制位上來說，新算出來的 `n-1` 只是相比舊的 `n-1` 左移了一位；
```
比如 16-1 = 15，就是 1 0000 - 1 = 0 1111；
新的 32-1 = 31，就是 10 0000 - 1 = 01 1111；
```
* 那麼這個值再和 `hash` 相與運算，節點要麼在原來位置，要麼在`原位置+舊的容量的位置`，也就是在最高位加上了一個原來的容量；
* 這樣計算的時候就不用頻繁的再計算，而是用一個加法就直接定位到要挪動的地方。
**上面講過的為什麼長度設定 2 的冪次，這裡也能作為一個優勢的解釋。**
原始碼如下：
```java
final Node[] resize() {
Node[] 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; //這裡把新的閾值和新的邊界值都*2
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
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;
//建立新陣列
@SuppressWarnings({"rawtypes","unchecked"})
Node[] newTab = (Node[])new Node[newCap];
table = newTab;
if (oldTab != null) {
//for迴圈就開始把所有舊的節點都放到新數組裡
for (int j = 0; j < oldCap; ++j) {
Node 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)e).split(this, newTab, j, oldCap);//如果是樹節點，拆分
else {
//是連結串列，保持順序，用do-while迴圈進行新的位置安排
Node loHead = null, loTail = null;
Node hiHead = null, hiTail = null;
Node next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {//用hash和oldCap的與結果，拆分連結串列
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}else {//用hash和oldCap的與結果，拆分連結串列
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;
newTab[j + oldCap] = hiHead;//放在新索引位置，就是加上 oldCap
}
}
}
}
}
return newTab;
}
```
## 3.5 remove 和 removeNode 刪除方法
remove 直接呼叫的 removeNode 方法，類似於前面的 put 呼叫 putVal 。
keys = map.keySet();
for (String key: keys){
System.out.println(key + map.get(key));//根據key得到value
}
```
也可以拿到所有的 value 需要用 Collection 來接收：
```java
Collection values = map.values();
for (Integer v: values){
System.out.println(v);
}
```
也可以獲取到所有的鍵值對Entry 的 Set 集合，然後拿到對應的迭代器進行遍歷：
```java
Set> entries = map.entrySet();
Iterator> iterator = entries.iterator();
while (iterator.hasNext()){
Map.Entry entry = iterator.next();
System.out.println(entry.getKey()+entry.getValue());//得到key和value
}
```
jdk 1.8 之後，還增加了一個 forEach 方法，可以接口裡的這個方法本身也是通過第二種方法實現的，在HashMap 裡重寫了這個方法，變成了對 table 陣列的遍歷，使用的時候，用 lambda 表示式傳入泛型就可以。
```java
map.forEach((key,value)->{
System.out.println(key + value);
});
```
這種方法其實用到的也屬於設計模式的代理模式
# 四、總結 jdk 1.7 和 1.8 之後關於 HashMap 的區別
## 4.1 資料結構的使用
- **1.7 ：單鏈表**
- **1.8 ：單鏈表，如果連結串列長度>8且陣列長度已經>64，轉為紅黑樹**
關於陣列本身，1.7 是一個 Entry 型別的陣列，1.8是一個 Node 型別。
## 4.2 什麼時候擴容？
**1.7 擴容時機**
* 擴容只有一種情況。利用了兩個資訊:
1. `陣列長度 * 載入因子`。載入因子預設情況是 `0.75` ，等鍵值對個數 `size` 達到了`陣列長度 * 載入因子`；
2. 產生雜湊衝突，當前插入的時候陣列的這個位置已經不為空了。
擴容後，新增元素。
**1.8 的擴容時機**
先新增元素，再看是否需要擴容。
* 擴容的第一種情況。
`陣列長度 * 載入因子。`載入因子預設情況是 `0.75` ，等鍵值對個數 `size` 達到了`陣列長度 * 載入因子`（這點判斷是一樣的）
* 擴容的第二種情況。
當其中某一個**連結串列的元素**個數達到 `8` 個，走到轉樹節點的方法裡，但是又發現**陣列長度**沒有達到 `64` ，則**擴容**而不轉紅黑樹。
## 4.3 擴容的實現
**1.7 擴容的實現**
* `陣列長度 * 2` 操作；
* 然後用一個 transfer 方法進行資料遷移，`transfer` 裡，對單向連結串列進行一個一個 `hash` 重新計算並且安排，採用頭插法來安排單向連結串列，把節點都安排好。
但是如果多執行緒的情況下，有別的執行緒先完成了擴容操作，這個時候連結串列的重新挪動已經導致節點位置的變化，切換回這個執行緒的時候，繼續改變連結串列指標就可能會產生環，然後這個執行緒死迴圈。
> 具體就是 7 的擴容方法在遷移的時候採用的是頭插法，那麼比如兩個元素 ab一個連結串列，執行緒1和2都發現要擴容，就會去呼叫transfer方法：
>
> 1. 1 先讀取了 e 是 a，next 是 b，但是沒來得及繼續操作就掛起了；
> 2. 2 開始讀取，並採用頭插法就是遍歷ab，先把a移到新陣列的位置，此時a.next = null；繼續遍歷到 b，b移到新位置，b.next = a；（形成了 b->a）
> 3. 這時候切換到了執行緒 1 執行，本來已經再迴圈裡面記錄了 e 和 e.next 了，然而這時**本來陣列都變新的了**，所以修改的時候計算位置啥的還是這個新數組裡，不會變，因為計算的肯定是一樣的， a.next = b，而前面就修改過了b.next = a，這樣已經是環了，那麼執行緒 1 繼續while，一直next，死迴圈。
**1.8 擴容的實現**
因為是先插入，再擴容，所以插入的時候對於連結串列就是一個尾插法。
然後如果達到了擴容的條件，也就先進行`陣列長度 * 2` 操作，直接在 `resize` 方法裡完成資料遷移，這裡因為資料結構已經有連結串列+紅黑樹兩種情況：
1. 如果是`連結串列`，把單鏈表進行資料遷移，充分利用與運算，將單鏈錶針對不同情況拆斷，放到新陣列的不同位置；
2. 如果是`紅黑樹`，樹節點裡維護了相當於雙向連結串列的指標，重新處理，如果處理之後發現樹的節點（雙向連結串列）小於等於 6 ，還會再操作把樹又轉換為單鏈表。
但是如果在多執行緒的情況下，不會形成環連結串列，但是可能會丟失資料，因為會覆蓋到一樣的新