HashMap、ConcurrentHashMap物件put(K key, V value)方法實現
以下原始碼版本為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
*/
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;
}
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、遍歷連結串列、紅黑樹。