【JDK源碼分析系列】ConcurrentHashMap 源碼分析 -- 增、刪、查操作
【0】ConcurrentHashMap 整體架構
構成說明
採用transient volatile HashEntry<K,V>[] table保存數據，採用table數組元素作爲鎖，從而實現了對每一行數據進行加鎖，併發控制使用Synchronized和CAS來操作
採用table數組＋單向鏈表＋紅黑樹的結構
ConcurrentHashMap 和 HashMap 比較
相同之處
1. 數組、鏈表結構幾乎相同，所以底層對數據結構的操作思路是相同的
2. 都實現了 Map 接口，繼承了 AbstractMap 抽象類，所以大多數的方法也都是相同的，
HashMap 有的方法，ConcurrentHashMap 幾乎都有，
當需要從 HashMap 切換到 ConcurrentHashMap 時，無需關心兩者之間的兼容問題
不同之處
1. 紅黑樹結構略有不同，
HashMap 的紅黑樹中的節點叫做 TreeNode，TreeNode 不僅僅有屬性，還維護着紅黑樹的結構，比如說查找，新增等等；
ConcurrentHashMap 中紅黑樹被拆分成兩塊，TreeNode 僅僅維護的屬性和查找功能，
新增了 TreeBin，來維護紅黑樹結構，並負責根節點的加鎖和解鎖
2. 新增 ForwardingNode (轉移)節點，擴容的時候會使用到，通過使用該節點，來保證擴容時的線程安全
【1】ConcurrentHashMap 新增數據
/**
* 單純的額調用putVal方法，並且putVal的第三個參數設置爲false
* 當設置爲false的時候表示這個value一定會設置
* 當設置爲true的時候，只有當這個key的value爲空的時候纔會設置
*/
public V put(K key, V value) {
return putVal(key, value, false);
}
//1:如果數組爲空，初始化，
//2:計算當前槽點有沒有值，沒有值的話，cas 創建，失敗繼續自旋
//3:如果槽點是轉發節點(正在擴容)，就會一直自旋等待擴容完成之後再新增
//4:槽點有值的，先鎖定當前槽點，其餘槽點不能操作
//4.1 : 如果是鏈表，新增值到鏈表的尾部
//4.2 : 如果是紅黑樹，在紅黑樹着色旋轉的時候，會考慮把紅黑樹的根節點鎖住
//5:check需不需要擴容，需要的話去擴容.
final V putVal(K key, V value, boolean onlyIfAbsent) {
// key value 不能爲空
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;
//table 是空的，初始化
if (tab == null || (n = tab.length) == 0)
// 處理初始化，併發的情況在initTable中處理，這裏不考慮
tab = initTable();
//如果當前索引位置沒有值，直接創建
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//cas 在 i 位置創建新的元素，當i位置是空時，創建成功結束for自循環，否則繼續自旋
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
//發現轉發節點，表明此時正在進行擴容，去幫助擴容
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
//槽點上有值的
else {
V oldVal = null;
//鎖定當前槽點，其餘線程不能操作，保證了安全
synchronized (f) {
//這裏再次判斷 i 索引位置的數據沒有被修改
//binCount 被賦值的話，說明走到了修改表的過程裏面
//保證鎖住的是hash桶的第一個節點，這樣阻止其他寫操作進入，
//如果鎖住的不是第一個節點，那麼重新開始循環
if (tabAt(tab, i) == f) {
//鏈表
if (fh >= 0) {
//因爲第一個節點處理了，這裏賦值爲1
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
//找到“相等”的節點，看看是否需要更新value的值
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;
}
}
}
//紅黑樹，這裏沒有使用 TreeNode,使用的是 TreeBin，TreeNode 只是紅黑樹的一個節點
//TreeBin 持有紅黑樹的引用，並且會對其加鎖，保證其操作的線程安全
else if (f instanceof TreeBin) {
Node<K,V> p;
//設置爲2，保證addCount中能夠進行擴容判斷，
//同時也不會觸發鏈表轉化爲紅黑樹的操作
binCount = 2;
//滿足if的話，把老的值給oldVal
//在putTreeVal方法裏面，在給紅黑樹重新着色旋轉的時候
//會鎖住紅黑樹的根節點
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
//binCount不爲空，並且 oldVal 有值的情況，說明已經新增成功了
if (binCount != 0) {
// 鏈表是否需要轉化成紅黑樹
if (binCount >= TREEIFY_THRESHOLD)
//鏈表轉換爲紅黑樹
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
//這一步幾乎走不到，槽點已經上鎖，只有在紅黑樹或者鏈表新增失敗的時候
//纔會走到這裏，這兩者新增都是自旋的，幾乎不會失敗
break;
}
}
}
//check 容器是否需要擴容，如果需要去擴容，調用 transfer 方法去擴容
//如果已經在擴容中了，check完成
addCount(1L, binCount);
return null;
}
【2】ConcurrentHashMap 查找數據流程
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
//計算hashcode
int h = spread(key.hashCode());
//不是空的數組 && 並且當前索引的槽點數據不是空的
//否則該key對應的值不存在，返回null
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
//槽點第一個值和key相等，直接返回
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
else if (eh < 0)
// hash桶的第一個節點的hash值小於0，代表它是特殊節點，使用特化的查找方式進行查找
// ForwardingNode會把find轉發到nextTable上再去執行一次
// TreeBin則根據自身讀寫鎖情況，判斷是用紅黑樹方式查找，還是用鏈表方式查找
// ReservationNode本身只是爲了synchronized有加鎖對象而創建的空的佔位節點，
// 因此本身hash桶是沒節點的，一定找不到，直接返回null
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;
}
【3】ConcurrentHashMap 刪除數據流程
public V remove(Object key) {
return replaceNode(key, null, null);
}
// remove刪除，可以看成是用null替代原來的節點
final V replaceNode(Object key, V value, Object cv) {
int hash = spread(key.hashCode());
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
// 沒有節點，刪除不了，直接退出
if (tab == null || (n = tab.length) == 0 ||
(f = tabAt(tab, i = (n - 1) & hash)) == null)
break;
// 發現轉發節點，表明此時正在進行擴容，去幫助擴容
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
V oldVal = null;
boolean validated = false;
//這裏跟put一樣，嘗試鎖住hash桶的第一個結點，要保證鎖住的是第一個結點
synchronized (f) {
//確保鎖住的是第一個節點
if (tabAt(tab, i) == f) {
//處理鏈表相關的刪除/替換操作
if (fh >= 0) {
validated = true;
for (Node<K,V> e = f, pred = null;;) {
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
//確定了待刪除的值
V ev = e.val;
if (cv == null || cv == ev ||
(ev != null && cv.equals(ev))) {
oldVal = ev;
//value != null 表明執行的是替換操作
if (value != null)
e.val = value;
//進行刪除節點 e 的操作
else if (pred != null)
pred.next = e.next;
//刪除的是第一個節點，就重設第一個節點，此時相當於已經釋放了鎖
else
setTabAt(tab, i, e.next);
}
break;
}
pred = e;
if ((e = e.next) == null)
//判斷循環遍歷是否已經結束
break;
}
}
//處理紅黑樹相關的刪除/替換操作
else if (f instanceof TreeBin) {
validated = true;
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> r, p;
//在紅黑樹中確定待刪除/替換的節點
if ((r = t.root) != null &&
(p = r.findTreeNode(hash, key, null)) != null) {
V pv = p.val;
if (cv == null || cv == pv ||
(pv != null && cv.equals(pv))) {
oldVal = pv;
//value != null 表明進行替換操作
if (value != null)
p.val = value;
//紅黑樹刪除節點
//removeTreeNode : 紅黑樹的規模太小時，返回true
else if (t.removeTreeNode(p))
//處理紅黑樹退化爲鏈表的情況
setTabAt(tab, i, untreeify(t.first));
}
}
}
}
}
// 下面這一段判斷是否是刪除操作，是刪除操作就把計數值減1
if (validated) {
if (oldVal != null) {
if (value == null)
addCount(-1L, -1);
return oldVal;
}
break;
}
}
}
return null;
}
致謝
本博客爲博主的學習實踐總結，並參考了衆多博主的博文，在此表示感謝，博主若有不足之處，請批評指正。