前言
看標題就知道本篇文章主角是ConcurrentHashMap，在講解它之前有幾個問題有必要弄清楚。(本文都是基於jdk1.8進行分析)
什麼是ConcurrentHashMap?
如果看過我之前寫的關於HashMap的文章，應該知道它是基於key-value形式存儲數據的一種hash存儲表，ConcurrentHashMap的存儲結構和HashMap是一樣的。
ConcurrentHashMap和HashMap的不同點
雖然都可以用來進行key-value對存儲，但是HashMap是線程不安全的，但是ConcurrentHashMap是線程安全的。這也意味着前者在多線程環境可能會出現數據丟失的情況，後者則可以保證讀取數據的安全性。
ConcurrentHashMap繼承圖
爲了方便簡潔，之後ConcurrentHashMap都簡稱爲CHM
案例
在分析具體的代碼之前，讓我們先看一個CHM的使用案例
public class Bootstrap {
private static ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
// private static HashMap<String, String> map = new HashMap<>();
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 400; i++) {
map.put(String.valueOf(i), String.valueOf(i));
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 200; i++) {
map.put(String.valueOf(i), String.valueOf(i));
}
});
Thread thread3 = new Thread(() -> {
for (int i = 0; i < 400; i++) {
map.remove(String.valueOf(i));
}
});
thread1.start();
thread2.start();
thread3.start();
}
}
這個案例很簡單，定義了三個線程同時對CHM進行數據的增加和刪除操作，對於CHM來說可以保證數據不會丟失，確保多線程下數據安全性問題。同樣如果用HashMap來代替的話是可能出現數據被覆蓋的風險的（關於HashMap可以看我之前的文章），本文就通過案例來進入具體源碼的講解
源碼解析
對於CHM源碼的解析，我主要通過三個方向進行闡述：分別是CHM的初始化、添加元素的操作（put）、擴容機制。通過這三個方面就可以比較清楚CHM是進行數據保存已經如何確保線程安全的。
初始化
首先從初始化開始，先從我們案例的初始化開始：
public ConcurrentHashMap() {
}
可以看見，如果你沒有指定任何參數，初始化的時候CHM是不會做任何操作，當然你也可以提前指定好一些參數：
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}
//涉及到的常量:
//MAXIMUM_CAPACITY是給定的可能的最大容量值
private static final int MAXIMUM_CAPACITY = 1 << 30;
private static final int tableSizeFor(int c) {
int n = c - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
上面的代碼是指定了initialCapacity，通過initialCapacity可以計算出對應的容量:判斷它是否比MAXIMUM_CAPACITY的一半還大，如果是的話直接將容量設置爲MAXIMUM_CAPACITY,否則通過tableSizeFor函數將它設置爲離c最近的2的冪次方的數（此函數我在HashMap源碼解析中有具體的說明），最後將計算好的值賦值給sizeCtl（這個變量是CHM的關鍵變量，之後會有詳細講解）。到這邊CHM的初始化就結束了。
put方法
初始化完成後，就可以調用put方法來存放值了，具體的代碼如下：
public V put(K key, V value) {
return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
//需要注意的是CHM的key和value都是不能爲空的
if (key == null || value == null) throw new NullPointerException();
#1 int hash = spread(key.hashCode());
//該值用來計算鏈表的節點數
int binCount = 0;
//進入自旋操作
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
#2 if (tab == null || (n = tab.length) == 0)
tab = initTable();
//如果數組不爲空則需要去查找對應的節點，通過CAS的方式去定
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
#3 if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
#4 else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
V oldVal = null;
//通過synchronized將節點進行鎖定
#5 synchronized (f) {
//判斷在鎖定之前節點有沒有被修改，防止其他線程的操作
if (tabAt(tab, i) == f) {
//判斷節點hash是否大於0，大於0則表示是鏈表
if (fh >= 0) {
//binCount的值設置爲1，binCount用來計算鏈表結點的個數
binCount = 1;
//進行循環遍歷，如果key和hash都是相等的，更新值
//注意binCount的值計算的是新節點添加的之前的鏈表的個數，後面會在新節點到來的時候去判斷，如果加入新的節點，鏈表長度已經達到了8，就會進行樹的轉換，
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) {
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) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
#6 if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
#7 addCount(1L, binCount);
return null;
}
涉及到的常量：
//CHM存放數據的表
transient volatile Node<K,V>[] table;
//轉換成樹的臨界點
static final int TREEIFY_THRESHOLD = 8;
這一塊我主要是針對數據存放來講解，涉及到擴容會放到下一節統一分析。首先我們可以思考一個問題：CHM存放數據和HashMap比有什麼挑戰？很顯然，是需要考慮在多線程環境如何讓數據安全的存放到指定的節點，我對put的主要步驟會進行編號，下面我們來一一分析：
#1：第一步很顯然，我們需要對key進行hash值的計算，但是它的計算方法和HashMap有點詫異我們看一下代碼：
static final int spread(int h) {
return (h ^ (h >>> 16)) & HASH_BITS;
}
//涉及常量:
static final int HASH_BITS = 0x7fffffff;
可以看見總體上是和HashMap類似，但是多了一個HASH_BITS,它是一個16進制的數，轉換成二進制數的話除了最高位是0其餘都是1，通過和它取餘，那麼獲取到的hash值永遠是大於0的。至於爲何要確保hash值大於0，是因爲CHM存在hash的負數的其他節點用來標識一些特別的功能。
#2：這一步是在table爲空情況下，需要進行初始化操作，這邊先用一張圖來解釋多線程下如何確保安全初始化：
具體代碼如下:
private final Node<K,V>[] initTable() {
//定義一個臨時節點變量和一個int類型變量sc
Node<K,V>[] tab; int sc;
//當table爲空或者長度等於0的情況下進行循環
while ((tab = table) == null || tab.length == 0) {
//這裏判斷sizeCtl的值是否小於0，這個值在初始化的時候提到過，這邊用它來判斷是否需要進行初始化
//小於0是因爲已經有別的線程正在初始化table數組，需要暫停線程
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
//否則通過CAS的方式直接操作內存將sizeCtl設置爲-1，表示當前線程正在初始化
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
//此時第二次判斷table是否爲空，來防止其他線程已經初始化了
if ((tab = table) == null || tab.length == 0) {
//設置sizeCtl的值，如果>0直接用否則設置成默認值16
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
//初始化節點數組賦值給table
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
//設置新的sizeCtl用來判斷下一次擴容的臨界點
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
//涉及常量:
//默認的表容量
private static final int DEFAULT_CAPACITY = 16;
#3：這一步是數組存在，但是定位到的節點不存在，那麼直接通過CAS的方式操作內存，來對節點進行創建
#4：這一步定位到的節點的hash值是MOVED，表示別的線程正在對該節點進行擴容操作，那麼就需要去加入擴容。這邊不詳細講擴容
#5: 這步是真正的添加新的數據，主要步驟我在代碼中進行註釋說明。
#6：在數據添加完成後，通過binCount判斷鏈表的長度是否大於了8，如果是的話需要將鏈表轉換成紅黑樹
#7：最後一步是發生在添加數據完成之後，主要有兩個功能：添加計數以及判斷是否需要擴容，具體代碼如下:
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
//如果counterCells數組不爲空或者CAS方式設置baseCount失敗的話，表示多個線程修改了table
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true;
if (as == null || (m = as.length - 1) < 0 ||
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
fullAddCount(x, uncontended);
return;
}
if (check <= 1)
return;
s = sumCount();
}
//...省略擴容相關
}
CHM中計數涉及到baseCount和CounterCell兩個概念，一種情況是沒有競爭關係，那麼直接通過CAS的方式添加baseCount即可,如果是有競爭的話，就用CounterCell數組去計數，因爲沒有線程都有唯一的Probe值通過該值每一個線程都會對應到CounterCell數組的一個位置然後進行數的疊加。如果在疊加過程還是有衝突，則需要對CounterCell數組的操作也進行自旋操作直到數添加成功。
CHM通過這種方式來提高多線程環境下累加count的效率，類似分而治之的思想。
擴容
對於擴容，主要有兩處地方涉及到：
新增元素後
這是在put完成後會判斷當前元素容量時候需要進行擴容，相關代碼如下：
private final void addCount(long x, int check) {
.....
//如果鏈表之前的節點數大於等於0，就要去判斷一次，添加了新元素後情況如何
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
//首先是要滿足條件:
//1. 當前元素個數比sizeCtl大,達到擴容的閾值
//2. table表不能爲空並且table的容量小於MAXIMUM_CAPACITY
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
//
int rs = resizeStamp(n);
//如果sc小於0表示有線程正在進行擴容
if (sc < 0) {
//如果滿足以下幾個條件的任意一種，那麼就不在需要擴容
//1. (sc >>> RESIZE_STAMP_SHIFT) != rs 當sizeCtl無符號右移16位後不等rs
//2. sc==rs+1
//3. sc==rs+MAX_RESIZERS
//4. (nt = nextTable) == null
//5. transferIndex<=0
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
//如果上面的條件都不滿足，那麼通過CAS的方式去設置sc，將它+1，如果成功的話表示當前線程需要進行擴容
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
//進行擴容操作
transfer(tab, nt);
}
//如果sc>0,表示還沒有線程正在進行擴容，將sc設置爲 (rs << RESIZE_STAMP_SHIFT) + 2，它是一個負數
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
//進行擴容
transfer(tab, null);
s = sumCount();
}
}
resizeStamp方法:計算出擴容的標誌位
static final int resizeStamp(int n) {
return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}
0000 0000 0000 0000 0000 0000 0000 1000
0000 0000 0000 0000 1000 0000 0000 0000
---------------------------------------
0000 0000 0000 0000 1000 0000 0000 1000
具體擴容方法:
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
//定義兩個變量，n表示tab的長度，stride(步的意思)變量
int n = tab.length, stride;
//這邊去計算cpu核數，如果大於1那麼就將stride賦值爲(n >>> 3) / NCPU，否則就賦值爲tab的長度
//然後判斷stride是否比MIN_TRANSFER_STRIDE（16）小，如果比它小則將stride賦值爲16
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
//如果nextTab等於空，需要做如下操作
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
//去初始化新的節點數組，該數組用來存放擴容後的數據，並且length是原來的兩倍
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
//然後將nt輔助給nextTable
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
//如果操作錯誤，則將sizeCtl設置爲Integer.MAX_VALUE，並且停止擴容
sizeCtl = Integer.MAX_VALUE;
return;
}
//做完後此時的nextTable就是初始化的新的數組
nextTable = nextTab;
//transferIndex設置爲16，表示轉移數據從原來的最後一個槽開始
transferIndex = n;
}
//如果nextTable已經初始化過了，那麼獲取新數組的長度
int nextn = nextTab.length;
//並且將nextTab封裝爲ForwardingNode節點
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
//定義兩個標誌位，advance和finishing
boolean advance = true;
boolean finishing = false; // to ensure sweep before committing nextTab
//進入循環，並且初始化i和bound爲0
for (int i = 0, bound = 0;;) {
//定義一個節點變量f和一個int變量fh
Node<K,V> f; int fh;
//進入循環，當advance爲true的時候
while (advance) {
//這邊又定義了兩個變量nextIndex和nextBound
int nextIndex, nextBound;
//如果滿足將i減1後大於bound或者finishing的值爲true的時候，就把advance設置爲false
if (--i >= bound || finishing)
advance = false;
//如果nextIndex也就是transefer<=0的時候將i-1並且把advance設置爲false
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
//除此之外，將transfer設置爲nextbound，也就是判斷nextIndex是否>16,如果是的話設置爲 nextIndex - stride
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
//將區間下標設置爲nextBound
bound = nextBound;
//如果是16則i=15,這是對i的第一次賦值
i = nextIndex - 1;
//然後將推進標識設置爲false
advance = false;
}
}
//在循環結束後，就有如下幾種情況
//如果i<0或者i>=數組長度或者i+n的值大於新數組的長度
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
//就去判斷finishing是否爲true，第一次進來肯定爲false
if (finishing) {
//是的話將nextTable設置爲null
//nextTab設置爲talbe的值
//設置新的sizeCtl的值
//最後返回標識擴容結束
nextTable = null;
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);
return;
}
//如果finishing不爲true，第一次會進入這個條件
//將sizeCtl的值-1
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
如果sc-2不等於那麼表示沒有結束幫助擴容
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
//如果表示幫助擴容結束那麼就將finishing和advance都設置爲true
finishing = advance = true;
i = n; // recheck before commit
}
}
//第二種情況是根據i，這邊i是15獲取對應的節點，如果爲空
else if ((f = tabAt(tab, i)) == null)
//那麼就去將fwd的節點設置進去，用去佔位表示正在擴容
advance = casTabAt(tab, i, null, fwd);
//如果節點不是空的並且已經是fwd節點了
else if ((fh = f.hash) == MOVED)
//那麼就繼續推進，區別的節點進行擴容
advance = true; // already processed
else {
//如果是正常的節點，那麼就要進行擴容操作
//通過synchronized將節點進行同步
synchronized (f) {
//在此之前，再次判斷節點是否變化，沒變的話正式進行擴容
if (tabAt(tab, i) == f) {
定義ln和hn兩個節點變量
Node<K,V> ln, hn;
如果hash>=0,表示是正常的節點
if (fh >= 0) {
//通過fh & n去計算節點在擴容後是否在原來的位置
int runBit = fh & n;
Node<K,V> lastRun = f;
for (Node<K,V> p = f.next; p != null; p = p.next) {
遍歷鏈表，判斷是否和runBit相等，如果不是則將runBit設置爲新的值，並且將lastRun設置爲當前節點
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
//0代表還在原來的位置
if (runBit == 0) {
ln = lastRun;
hn = null;
}
//代表在n+原來的位置
else {
hn = lastRun;
ln = null;
}
//去遍歷鏈表，然後創建新的節點，根據時候在原來的位置分別進行賦值，這個HashMap擴容機制類似
//需要注意的是新數組中的鏈表數據的順序可能和原來的是不一樣的
for (Node<K,V> p = f; p != lastRun; p = p.next) {
int ph = p.hash; K pk = p.key; V pv = p.val;
if ((ph & n) == 0)
ln = new Node<K,V>(ph, pk, pv, ln);
else
hn = new Node<K,V>(ph, pk, pv, hn);
}
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
else if (f instanceof TreeBin) {
...由於代碼過長，這邊省略對樹的擴容
}
}
}
}
}
}
新增元素時
在添加新的元素時，可能會遇到節點正在進行擴容的情況，那麼當前線程就要去協助擴容，具體代碼如下：
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
//如果當前節點屬於FowWardingNode並且table不爲空，並且nextTable也不爲空
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
int rs = resizeStamp(tab.length);
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
//去進行擴容操作，將sc+1
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}
總結
本文主要講了CHM如何進行數據的存放已經如何進行擴容，並且解析了它是如何在多線程環境保證數據的安全性的
轉載請註明出處！鏈接