[學習筆記-Java集合-8] Map - ConcurrentHashMap 源碼分析（二）
刪除元素
刪除元素跟添加元素同樣，都是先找到元素所在的桶，而後採用分段鎖的思想鎖住整個桶，再進行操做。數組
public V remove(Object key) {
// 調用替換節點方法
return replaceNode(key, null, null);
}
final V replaceNode(Object key, V value, Object cv) {
// 計算hash
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)
// 若是目標key所在的桶不存在，跳出循環返回null
break;
else if ((fh = f.hash) == MOVED)
// 若是正在擴容中，協助擴容
tab = helpTransfer(tab, f);
else {
V oldVal = null;
// 標記是否處理過
boolean validated = false;
synchronized (f) {
// 再次驗證當前桶第一個元素是否被修改過
if (tabAt(tab, i) == f) {
if (fh >= 0) {
// 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;
// 檢查目標節點舊value是否等於cv
if (cv == null || cv == ev ||
(ev != null && cv.equals(ev))) {
oldVal = ev;
if (value != null)
// 若是value不爲空則替換舊值
e.val = value;
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;
// 檢查目標節點舊value是否等於cv
if (cv == null || cv == pv ||
(pv != null && cv.equals(pv))) {
oldVal = pv;
if (value != null)
// 若是value不爲空則替換舊值
p.val = value;
else if (t.removeTreeNode(p))
// 若是value爲空則刪除元素
// 若是刪除後樹的元素個數較少則退化成鏈表
// t.removeTreeNode(p)這個方法返回true表示刪除節點後樹的元素個數較少
setTabAt(tab, i, untreeify(t.first));
}
}
}
}
}
// 若是處理過，無論有沒有找到元素都返回
if (validated) {
// 若是找到了元素，返回其舊值
if (oldVal != null) {
// 若是要替換的值爲空，元素個數減1
if (value == null)
addCount(-1L, -1);
return oldVal;
}
break;
}
}
}
// 沒找到元素返回空
return null;
}
- 計算hash；
- 若是所在的桶不存在，表示沒有找到目標元素，返回；
- 若是正在擴容，則協助擴容完成後再進行刪除操做；
- 若是是以鏈表形式存儲的，則遍歷整個鏈表查找元素，找到以後再刪除；
- 若是是以樹形式存儲的，則遍歷樹查找元素，找到以後再刪除；
- 若是是以樹形式存儲的，刪除元素以後樹較小，則退化成鏈表；
- 若是確實刪除了元素，則整個map元素個數減1，並返回舊值；
- 若是沒有刪除元素，則返回null；
獲取元素
獲取元素，根據目標key所在桶的第一個元素的不一樣採用不一樣的方式獲取元素，關鍵點在於find()方法的重寫。安全
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
// 計算hash
int h = spread(key.hashCode());
// 若是元素所在的桶存在且裏面有元素
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
// 若是第一個元素就是要找的元素，直接返回
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
else if (eh < 0)
// hash小於0，說明是樹或者正在擴容
// 使用find尋找元素，find的尋找方式依據Node的不一樣子類有不一樣的實現方式
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;
}
- hash到元素所在的桶；
- 若是桶中第一個元素就是該找的元素，直接返回；
- 若是是樹或者正在遷移元素，則調用各自Node子類的find()方法尋找元素；
- 若是是鏈表，遍歷整個鏈表尋找元素；
- 獲取元素沒有加鎖；
獲取元素個數
元素個數的存儲也是採用分段的思想，獲取元素個數時須要把全部段加起來。多線程
public int size() {
// 調用sumCount()計算元素個數
long n = sumCount();
return ((n < 0L) ? 0 :
(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
(int)n);
}
final long sumCount() {
// 計算CounterCell全部段及baseCount的數量之和
CounterCell[] as = counterCells; CounterCell a;
long sum = baseCount;
if (as != null) {
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
return sum;
}
- 元素的個數依據不一樣的線程存在在不一樣的段裏；（見addCounter()分析）
- 計算CounterCell全部段及baseCount的數量之和；
- 獲取元素個數沒有加鎖；
總結
（1）ConcurrentHashMap是HashMap的線程安全版本；併發
（2）ConcurrentHashMap採用（數組 + 鏈表 + 紅黑樹）的結構存儲元素；學習
（3）ConcurrentHashMap相比於一樣線程安全的HashTable，效率要高不少；線程
（4）ConcurrentHashMap採用的鎖有 synchronized，CAS，自旋鎖，分段鎖，volatile等；code
（5）ConcurrentHashMap中沒有threshold和loadFactor這兩個字段，而是採用sizeCtl來控制；資源
（6）sizeCtl = -1，表示正在進行初始化；rem
（7）sizeCtl = 0，默認值，表示後續在真正初始化的時候使用默認容量；get
（8）sizeCtl > 0，在初始化以前存儲的是傳入的容量，在初始化或擴容後存儲的是下一次的擴容門檻；
（9）sizeCtl = (resizeStamp << 16) + (1 + nThreads)，表示正在進行擴容，高位存儲擴容郵戳，低位存儲擴容線程數加1；
（10）更新操做時若是正在進行擴容，當前線程協助擴容；
（11）更新操做會採用synchronized鎖住當前桶的第一個元素，這是分段鎖的思想；
（12）整個擴容過程都是經過CAS控制sizeCtl這個字段來進行的，這很關鍵；
（13）遷移完元素的桶會放置一個ForwardingNode節點，以標識該桶遷移完畢；
（14）元素個數的存儲也是採用的分段思想，相似於LongAdder的實現；
（15）元素個數的更新會把不一樣的線程hash到不一樣的段上，減小資源爭用；
（16）元素個數的更新若是仍是出現多個線程同時更新一個段，則會擴容段（CounterCell）；
（17）獲取元素個數是把全部的段（包括baseCount和CounterCell）相加起來獲得的；
（18）查詢操做是不會加鎖的，因此ConcurrentHashMap不是強一致性的；
（19）ConcurrentHashMap中不能存儲key或value爲null的元素；
學習重點
ConcurrentHashMap中值得學習的技術
（1）CAS + 自旋，樂觀鎖的思想，減小線程上下文切換的時間；
（2）分段鎖的思想，減小同一把鎖爭用帶來的低效問題；
（3）CounterCell，分段存儲元素個數，減小多線程同時更新一個字段帶來的低效；
（4）@sun.misc.Contended（CounterCell上的註解），避免僞共享；
（5）多線程協同進行擴容；
ConcurrentHashMap 併發下使用問題
看下面的使用例子：
private static final Map<Integer, Integer> map = new ConcurrentHashMap<>();
public void unsafeUpdate(Integer key, Integer value) {
Integer oldValue = map.get(key);
if (oldValue == null) {
map.put(key, value);
}
}
若是有多個線程同時調用unsafeUpdate()這個方法，ConcurrentHashMap是沒法保證線程安全的。
由於get()以後if以前可能有其它線程已經put()了這個元素，這時候再put()就把那個線程put()的元素覆蓋了。
那怎麼修改呢？
使用putIfAbsent()方法，它會保證元素不存在時才插入元素，以下：
public void safeUpdate(Integer key, Integer value) {
map.putIfAbsent(key, value);
}
那麼，若是上面oldValue不是跟null比較，而是跟一個特定的值好比1進行比較怎麼辦？也就是下面這樣：
public void unsafeUpdate(Integer key, Integer value) {
Integer oldValue = map.get(key);
if (oldValue == 1) {
map.put(key, value);
}
}
這樣的話就沒辦法使用putIfAbsent()方法了。
其實，ConcurrentHashMap還提供了另外一個方法叫replace(K key, V oldValue, V newValue)能夠解決這個問題。
replace(K key, V oldValue, V newValue)這個方法可不能亂用，若是傳入的newValue是null，則會刪除元素。
public void safeUpdate(Integer key, Integer value) {
map.replace(key, 1, value);
}
那麼，若是if以後不是簡單的put()操做，而是還有其它業務操做，以後纔是put()，好比下面這樣，這該怎麼辦呢？
public void unsafeUpdate(Integer key, Integer value) {
Integer oldValue = map.get(key);
if (oldValue == 1) {
System.out.println(System.currentTimeMillis());
/**
* 其它業務操做
*/
System.out.println(System.currentTimeMillis());
map.put(key, value);
}
}
這時候就沒辦法使用ConcurrentHashMap提供的方法了，只能業務本身來保證線程安全了，好比下面這樣：
public void safeUpdate(Integer key, Integer value) {
synchronized (map) {
Integer oldValue = map.get(key);
if (oldValue == null) {
System.out.println(System.currentTimeMillis());
/**
* 其它業務操做
*/
System.out.println(System.currentTimeMillis());
map.put(key, value);
}
}
}
這樣雖然不太友好，可是最起碼能保證業務邏輯是正確的。固然，這裏使用ConcurrentHashMap的意義也就不大了，能夠換成普通的HashMap了。
- 1. [學習筆記-Java集合-7] Map - ConcurrentHashMap 源碼分析（一）
- 2. [學習筆記-Java集合-5]Map - LinkedHashMap源碼分析
- 3. [學習筆記-Java集合-11] Map - ConcurrentSkipListMap源碼分析
- 4. [學習筆記-Java集合-6] Map - WeakHashMap源碼分析
- 5. [學習筆記-Java集合-4] Map - HashMap源碼分析
- 6. java collection 集合源碼分析（二） map
- 7. [學習筆記-Java集合-9] Set - HashSet源碼分析
- 8. Java集合: ConcurrentHashMap源碼分析 JDK1.8
- 9. java集合框架----Map 源碼分析
- 10. [學習筆記-Java集合-13] Set - ConcurrentSkipListSet源碼分析
- 更多相關文章...
- • Scala Map(映射) - Scala教程
- • Scala Set(集合) - Scala教程
- • Tomcat學習筆記（史上最全tomcat學習筆記）
- • Java Agent入門實戰（二）-Instrumentation源碼概述
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 跳槽面試的幾個實用小技巧，不妨看看！
- 2. Mac實用技巧 |如何使用Mac系統中自帶的預覽工具將圖片變成黑白色?
- 3. Mac實用技巧 |如何使用Mac系統中自帶的預覽工具將圖片變成黑白色?
- 4. 如何使用Mac系統中自帶的預覽工具將圖片變成黑白色?
- 5. Mac OS非兼容Windows軟件運行解決方案——「以VMware & Microsoft Access爲例「
- 6. 封裝 pyinstaller -F -i b.ico excel.py
- 7. 數據庫作業三ER圖待完善
- 8. nvm安裝使用低版本node.js(非命令安裝)
- 9. 如何快速轉換圖片格式
- 10. 將表格內容分條轉換爲若干文檔
- 1. [學習筆記-Java集合-7] Map - ConcurrentHashMap 源碼分析（一）
- 2. [學習筆記-Java集合-5]Map - LinkedHashMap源碼分析
- 3. [學習筆記-Java集合-11] Map - ConcurrentSkipListMap源碼分析
- 4. [學習筆記-Java集合-6] Map - WeakHashMap源碼分析
- 5. [學習筆記-Java集合-4] Map - HashMap源碼分析
- 6. java collection 集合源碼分析（二） map
- 7. [學習筆記-Java集合-9] Set - HashSet源碼分析
- 8. Java集合: ConcurrentHashMap源碼分析 JDK1.8
- 9. java集合框架----Map 源碼分析
- 10. [學習筆記-Java集合-13] Set - ConcurrentSkipListSet源碼分析