由淺入深理解HashMap, 帶原始碼分析

HashMap 原始碼分析 · 發表 2019-03-25 21:53:00

摘要：本文按以下順序敘述: 官方文件中對HashMap介紹的解讀. 到原始碼中看看HashMap這些特性到底是如何實現的. 把原始碼啃下來有一種很爽的感覺, 相信你讀完後也能體會到~ 如發現有誤, 歡迎指出. 在開始之前, 先通過圖例對HashMap建立感性認...

本文按以下順序敘述:

官方文件中對HashMap介紹的解讀.
到原始碼中看看HashMap這些特性到底是如何實現的.

把原始碼啃下來有一種很爽的感覺, 相信你讀完後也能體會到~ 如發現有誤, 歡迎指出.

在開始之前, 先通過圖例對HashMap建立感性認識

如果不清楚雜湊表是一種什麼樣的資料結構的話, 可以先看書瞭解一下, 如果覺得看書麻煩, 推薦看一下浙大資料公開課中的第十一講雜湊查詢 , 瞭解了這種資料結構後理解HashMap就沒有問題了.

HashMap由一個數組組成, 對於每個鍵值對, 會通過對鍵進行雜湊計算, 直接得出該鍵值對儲存的位置, 保證了存取鍵值的操作擁有極其優良的時間效能.
當兩個鍵值對儲存的位置發生衝突時, 會通過連結串列把鍵值對在對應的位置上用連結串列連起來. 如果鏈太長的話, (在JDK1.8後)會把連結串列轉換為存取效率更高的紅黑樹, 以保證HashMap的整體存取效率.
HashMap中有專門記錄容量的引數, 如果容量增大到一定的值會進行擴容, 使得HashMap雜湊更均勻, 整體存取效率更高.

下面是基於官方文件的粗糙翻譯

HashMap和Hashtable是相似的, 只不過它是執行緒不安全的, 並且允許null值. 它不能保證鍵值對的有序性, 鍵值對的順序甚至會在使用的過程中發生變化 (擴容等操作會重新進行雜湊操作, 鍵值對的位置發生變化).
在雜湊函式能雜湊均勻的前提下, 它能保證put和get兩個基本操作有穩定的時間效能.
遍歷HashMap所需要的時間和它的容量是成正比的, 如果迭代效能很重要, 請不要把初始容量設定得過高(或把負載因子設定得過小, 過小則會經常進行重新雜湊的操作).
兩個引數影響著HashMap的效能: 初始容量和負載因子. 這裡的初始容量指建立Hash表時所開闢的記憶體空間. 負載因子是一個小數, 用於判斷HashMap是否已經滿了. 當map中的元素超過了負載因子和當前容量的乘積後, HashMap會進行擴容, 大概擴為原來大小的兩倍. (比如說負載因子是0.75, 初始容量是100, 當實際容量達到 0.75*100=75 時, HashMap就會進行擴容)
一般來說, 預設負載因子(0.75)在時間和空間成本之間提供了很好的平衡。設定一個更大的負載因子值雖然節省了空間，但是增加了查詢的時間成本(查詢時間的增加會影響HashMap的大部分操作，包括get和set)，所以在設定HashMap的初始容量的時候要考慮map中預期的裝填元素數量和負載因子的大小，以最大限度減少擴容的次數.
要注意的是HashMap是執行緒不安全的, 官方建議從外部實現對HashMap的同步操作, 官方給出的建議是
Map m = Collections.synchronizedMap(new HashMap(...));
當然也可以用 ConcurrentHashMap 替代.
使用iterator迭代器遍歷HashMap時有一個fail-fast快速容錯機制. 在使用迭代器遍歷容器的過程中, 任何對HashMap結構進行修改的都會導致 ConcurrentModificationException 併發修改異常. 如果不想這個異常出現, 但又想刪除某個元素, 就要呼叫iterator迭代器自身的 remove 方法. 如果沒有這個機制, 在迭代的過程中增刪元素可能會導致HashMap結構的變更(比如擴容), 繼續遍歷的時候便會出錯, 這一機制把這種風險扼殺在搖籃中.

原始碼分析

1. HashMap的建立

在建立HashMap之前, 先看看它的幾個基本屬性

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16, HashMap的預設初始容量

static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量, 如果在建立HashMap時顯示指定HashMap的大小, 則不能超過這個值, 否則會預設使用這個值

static final float DEFAULT_LOAD_FACTOR = 0.75f;//預設負載因子

static final int MIN_TREEIFY_CAPACITY = 64;//當HashMap的容量大於這個值, 一個位置衝突過多時才能轉為紅黑樹, 否則解決衝突過多的方式是擴容

static final int TREEIFY_THRESHOLD = 8;//衝突時元素會用連結串列連起來, 當連結串列的長度達到了這個值, 就會轉換為紅黑樹

static final int UNTREEIFY_THRESHOLD = 6;//當紅黑樹的結點數量少於這個值的時候, 會轉換回連結串列. 

/**
 * The next size value at which to resize (capacity * load factor).
 */
int threshold;//當前容量與負載因子的乘積, 用於判斷是否要擴容.

HashMap一共有4個構造器. 這裡只給出了無參構造, 如果清楚HashMap的使用環境, 可以使用其他有參構造設定初始容量和負載因子.
如果使用無參構造建立HashMap, 會把負載因子設定為0.75, 其他額外的屬性都按照預設值進行初始化.

/**
 * The load factor used when none specified in constructor.
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
 * The load factor for the hash table.
 *
 * @serial
 */
final float loadFactor;

//無參構造
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

至此, HashMap建立完畢. 在建立HashMap的時候, 並沒有為陣列分配空間, 那麼這些必要步驟什麼時候做呢? 請繼續看...

2. HashMap的使用

HashMap的使用, 無非就是鍵值對的儲存了, 先看存的程式碼.

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

我們發現在呼叫 put() 方法的時候其實呼叫的是 putVal() 方法.
putVal() 是個重要的方法, 通過方法, 我們能對HashMap有個深入的理解.

/**
 * Implements Map.put and related methods
 *
 * @param hash hash for keykey的hash code經過再次計算後得出hash值.
 * @param key the keykey值
 * @param value the value to putvalue值
 * @param onlyIfAbsent if true, don't change existing value
 * @param evict if false, the table is in creation mode.
 * @return previous value, or null if none
 */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
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) {
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;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}

分析如下:

Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;

resize()
resize()

這裡插入 resize() 方法的分析, 如需跳過,

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) // 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<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab; //如果是初始化HashMap, 到這裡就夠了, 會跳過if判斷並返回
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 { // preserve order般動資料
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;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}

首先判斷HashMap容量是否超過了預設的最大值, 如果是就不會進行擴容, 並返回原表.
然後確定新表的大小 newCap , 確定新表的threshold值(用於判斷是否要擴容) newThr .
確定好這兩個值後, 如果是初始化HashMap, 由於原表為空 oldTab == null , resize() 函式也就結束了, 返回初始好的新表.
如果 oldTab != null , 也就說這次呼叫 resize() 是進行擴容, 那麼在建立好新表後, 就要把原來的資料重新計算並搬運到新表中.
搬運資料的過程還是蠻有意思的, 分析如下:

在HashMap中計算元素存放位置的程式碼是 (n - 1) & hash
其中n是雜湊表陣列的長度, 這行程式碼保證了元素能落在陣列的下標範圍內
現在我們要進行擴容, 假設hash值為101010
初始容量 n = 16 , 計算地址: (n - 1) & hash = 1111& 101010 = 001010
擴後容量 n = 32 , 計算地址: (n - 1) & hash = 11111 & 101010 = 001010
我們發現hash值為101010的時候計算出來的地址是一樣的, 那麼這個元素就不用挪位了. 

再舉例:
假設當前元素hash值為1010101
初始容量 n = 16 , 計算地址: (n - 1) & hash = 1111& 1010101 = 0000101
擴後容量 n = 32 , 計算地址: (n - 1) & hash = 11111 & 1010101 = 0010101
我們發現這時兩個地址不相等, 新地址為: 原地址 + 原長度 (0000101 + 16) = 0010101

這是一個精心的設計, 是這樣的:
原來計算地址時 : (n - 1) = 1111 一共有4位
擴容後計算地址 : (n - 1) = 11111 多了一位, 多在了第五位
回頭看hash值
第一個hash值: 101010. 第五位為0
第二個hash值: 1010101. 第五位為1
設計的原理就是: 在計算地址的時候, (n - 1)會比原來多了一位, 假設多的是第n位. 
如果hash值的第n位為0那麼元素就不用移動, 如果為1, 就要移動到新位置. 

所以從嚴謹的角度看, 擴容的時候不是對每個元素重新計算雜湊, 
而是把每個位置上的元素分成兩類調整位置. 


else { // preserve order
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) {//判斷第n位是否為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;
newTab[j + oldCap] = hiHead;//移動的位置: 原位置 + 原長度
}
}

下面繼續是`putVal()`的分析

if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);

拿到陣列後, 根據hash值計算插入地址 tab[i = (n - 1) & hash] , 如果該地址中沒有元素, 就直接插入. 插入完判斷需不需要擴容 if (++size > threshold) , 如果需要就擴容, 不需要的話本次 put() 方法就結束了, 返回null.
如果插入的地方已經有元素了, 也就是發生了衝突.

if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;

首先會判斷Key是否相同, 如果相同, 就就行判斷是否能替換值, 能就替換

if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)//在日常使用中, 基本新value都會替換舊value
e.value = value;
afterNodeAccess(e);
return oldValue;
}

如果不相同, 就要尋找插入的位置, 如果當前桶裡裝的是連結串列, 則遍歷連結串列(遍歷的過程中仍會判斷是否有相同的key), 如果裝的是紅黑樹, 則按照紅黑樹的策略尋找插入點(期間仍會判斷是否有相同的key).

else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
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;
}
}

補充: 在桶裡裝連結串列的情況下, 插入元素後會判斷連結串列的長度有沒有達到轉換為紅黑樹的要求. 如果達到了就呼叫 treeifyBin() 方法.
但注意: 並不是呼叫了 treeifyBin() 就會把桶中的結構轉換為紅黑樹. 回想一下文章開頭提及的基本引數, 有一個引數是 MIN_TREEIFY_CAPACITY , 如果當前陣列長度還沒有達到這個引數的值, 是不會轉換結構的, 會進行擴容 resize() .

結束

看到這裡, HashMap在你的面前應該是沒有什麼祕密了.
曾經看過一個有關HashMap併發造成死迴圈的問題. 左耳朵耗子的部落格中有詳細的描述, 點此跳轉
但是這個問題在JDK1.8中已經處理了. 造成死迴圈的原因是擴容時重新插入連結串列時是倒序插入的, JDK1.8中用了兩條連結串列分別操作, 保證了連結串列插入到Map時還是按順序插入的, 避免了死迴圈.