HashMap、ConcurrentHashMap物件put(K key, V value)方法實現
阿新 • • 發佈：2019-01-08
以下原始碼版本為java8，與java7版本的HashMap原始碼有所差異，請區分。
HashMap物件put(K key, V value)原始碼
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @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
*/ put執行過程：
1、首先檢查hashmap是否為空，為空的話執行resize，相當於初始化一個map。
2、hashmap非空時，計算tab陣列下標[(n - 1) & hash]，判斷陣列物件是否為空，為空時新建一個node節點。
3、陣列物件非空，tab[i]非空，首先判斷該節點的key與即將put的key值是否相同，相同的話先講tab[i]對應的node儲存起來。
4、繼續判斷tab[i]是否為紅黑樹物件，若tab節點為紅黑樹，則執行一次樹物件put操作。
5、接下來處理tab[i]節點為連結串列物件，通過一個計數器binCount統計連結串列長度。如果tab[i]物件p的next為null，則連結串列到頭了，這個時候新建一個node<key,value>節點為p.next。
6、如果連結串列長度計數器binCount>7(8-1)，換句話說，連結串列長度大於8時，則進行紅黑色轉換。如果不滿足轉換條件，連結串列種插入新節點完畢，無需其他操作。
7、遍歷連結串列過程中，發現key值相同的節點時，直接break，執行最後面的value覆蓋即可。
8、針對存在相同key的節點，執行value覆蓋，並返回舊值。
9、針對新增node節點的情況，若tab大小超過閾值（容量*負載因子），執行resize擴容操作，返回null。
https://www.cnblogs.com/jzb-blog/p/6637823.html
resize執行過程：
由於java版本差異，jdk7與jdk8擴容機制還是存在差異，先看看jdk7版本的擴容實現，比較好理解：
java7版本的擴容方式即新建一個數組，遍歷老陣列元素，計算每個元素的下標[(length-1)&hash]，然後按照下標填充元素。
//傳入新的容量
void resize(int newCapacity) {
//引用擴容前的Entry陣列
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
//擴容前的陣列大小如果已經達到最大(2^30)了
if (oldCapacity == MAXIMUM_CAPACITY) {
//修改閾值為int的最大值(2^31-1)，這樣以後就不會擴容了
threshold = Integer.MAX_VALUE;
return;
}
//初始化一個新的Entry陣列
Entry[] newTable = new Entry[newCapacity];
//！！將資料轉移到新的Entry數組裡
transfer(newTable);
//HashMap的table屬性引用新的Entry陣列
table = newTable;
//修改閾值
threshold = (int) (newCapacity * loadFactor);
}
/**
這裡就是使用一個容量更大的陣列來代替已有的容量小的陣列，transfer()方法將原有Entry陣列的元素拷貝到新的Entry數組裡。
**/
void transfer(Entry[] newTable) {
//src引用了舊的Entry陣列
Entry[] src = table;
int newCapacity = newTable.length;
//遍歷舊的Entry陣列
for (int j = 0; j < src.length; j++) {
//取得舊Entry陣列的每個元素
Entry<K, V> e = src[j];
if (e != null) {
//釋放舊Entry陣列的物件引用（for迴圈後，舊的Entry陣列不再引用任何物件）
src[j] = null;
do {
Entry<K, V> next = e.next;
//！！重新計算每個元素在陣列中的位置
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i]; //標記[1]
newTable[i] = e; //將元素放在陣列上
e = next; //訪問下一個Entry鏈上的元素
} while (e != null);
}
}
}
static int indexFor(int h, int length) {
return h & (length - 1);
}
java8後的版本擴容機制引入了紅黑樹，擴容原理類似，但實現細節變更了：
參考文章：https://blog.csdn.net/z69183787/article/details/64920074?locationNum=15&fps=1
/**
* Initializes or doubles table size. If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
*
* @return the table
*/
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
// 空map初始化
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;
if (oldTab != null) {
// 遍歷老陣列
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 老陣列節點為孤點時，即子節點為null，通過e.hash & (newCap - 1)獲取陣列下標，將節點填充到該陣列物件中
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;
// 元素位置沒有發生變化
// 原hash與老容量進行與運算，loHead、loTail位置不變時的頭尾節點
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 元素位置發生變化
// hiHead、hiTail位置變化後新的頭節點和尾節點
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 位置不變時，(e.hash & oldCap) == 0，陣列當前下標指向loHead
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 位置變化時，陣列下標變為[j + oldCap]，指向頭節點
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
ConcurrentHashMap物件put(K key, V value)原始碼
參考文章：https://www.cnblogs.com/snowater/p/8087166.html
public V put(K key, V value) {
// 核心是呼叫putVal方法
return putVal(key, value, false);
}
public V putIfAbsent(K key, V value) {
// 如果key存在就不更新value
return putVal(key, value, true);
}
/** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
// key或value 為null都是不允許的，因為Forwarding Node就是key和value都為null，是用作標誌位的。
if (key == null || value == null) throw new NullPointerException();
// 根據key計算hash值，有了hash就可以計算下標了
int hash = spread(key.hashCode());
int binCount = 0;
// 可能需要初始化或擴容，因此一次未必能完成插入操作，所以新增上for迴圈
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// 表還沒有初始化，先初始化，lazily initialized
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// 根據hash計算應該插入的index，該位置上還沒有元素，則直接插入
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 空節點直接新增元素，然後退出迴圈
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
// static final int MOVED = -1; // hash for forwarding nodes
// 說明f為ForwardingNode，只有擴容的時候才會有ForwardingNode出現在tab中，因此可以斷定該tab正在進行擴容
else if ((fh = f.hash) == MOVED)
// 協助擴容
tab = helpTransfer(tab, f);
else {
V oldVal = null;
// 節點上鎖，hash值相同的節點組成的連結串列頭結點
synchronized (f) {
if (tabAt(tab, i) == f) {
if (fh >= 0) {
// 是連結串列節點
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
// 遍歷連結串列查詢是否包含該元素
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) {
// 遍歷連結串列，如果一直沒找到，則新建一個Node放到連結串列結尾
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) {
// 儲存舊的value用於返回
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value; // 替換舊的值
}
}
}
}
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
// 連結串列長度超過閾值（預設為8），則需要將連結串列轉為一棵紅黑樹
treeifyBin(tab, i);
if (oldVal != null)
// 如果只是替換，並未帶來節點的增加則直接返回舊的value即可
return oldVal;
break;
}
}
}
// 元素總數加1，並且判斷是否需要擴容
addCount(1L, binCount);
return null;
}
put操作總結：
1、初始化判斷，將節點直接插入tab[i]；
2、節點為連結串列的話，遍歷連結串列定位相同key的位置，有相同的就替換，沒有相同的就將新node插入到連結串列末尾。
3、節點為紅黑樹的話，遍歷樹節點，指向相應的更新、新增節點操作。
get操作總結：
1、通過tab[(n - 1) & hash])獲取陣列下標；
2、遍歷連結串列、紅黑樹。