ConcurrentHashMap(JDK1.8)學習記錄
看了忘忘了看系列之ConcurrentHashMap，本文主要記錄下通過看ConcurrentHashMap源碼學習到的知識點。主要有以下幾個點。文章稍長，需要耐心閱讀。
1、ConcurrentHashMap構造函數和相關屬性
2、ConcurrentHashMap使用示例
3、ConcurrentHashMap跟隨示例學原理
ConcurrentHashMap的出現主要是因爲HashMap在多線程情況下表現不好。那麼下面文章就跟着源碼學習下ConcurrentHashMap是如何在多線程下表現良好的。
1、ConcurrentHashMap構造函數和相關屬性
構造函數
ConcurrentHashMap的構造函數和HashMap的構造函數形式類似，但是在帶容量參數的構造函數中調用tableSizeFor函數時候稍有不同
// 無參構造函數，也是大家經常使用的
public ConcurrentHashMap() {
}
// 帶容量參數的構造函數
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
// 這裏爲什麼要將傳入的容量變爲大於1.5倍容量+1的最小的2的整數次方冪
// 還有待理解
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}
// 使用其他Map作爲參數構造函數
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
this.sizeCtl = DEFAULT_CAPACITY;
putAll(m);
}
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, 1);
}
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (initialCapacity < concurrencyLevel) // Use at least as many bins
initialCapacity = concurrencyLevel; // as estimated threads
long size = (long)(1.0 + (long)initialCapacity / loadFactor);
int cap = (size >= (long)MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
this.sizeCtl = cap;
}
屬性變量
// 下面列舉一些重要的屬性變量，許多變量和HashMap的還是挺相似的
// 最大table容量
private static final int MAXIMUM_CAPACITY = 1 << 30;
// 不帶參數構造時候，當添加第一個元素時候默認擴容的table大小
private static final int DEFAULT_CAPACITY = 16;
// table單個槽位樹化的閾值，槽位中鏈表節點樹大於這個值才嘗試樹化
static final int TREEIFY_THRESHOLD = 8;
// 一般當擴容之後單個槽位的節點數量會變少，當節點數量少於這個值時候將樹轉爲鏈表
static final int UNTREEIFY_THRESHOLD = 6;
// 樹化節點時候需要table容量大於下面這個值
static final int MIN_TREEIFY_CAPACITY = 64;
// 單個線程最小處理步長
private static final int MIN_TRANSFER_STRIDE = 16;
private static int RESIZE_STAMP_BITS = 16;
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
static final int MOVED = -1; // hash for forwarding nodes
static final int TREEBIN = -2; // hash for roots of trees
static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
// 實際存儲鍵值對的table
transient volatile Node<K,V>[] table;
// 擴容時候用到的引用
private transient volatile Node<K,V>[] nextTable;
// 暫時是table的鍵值對數量
private transient volatile long baseCount;
// sizeCtl：
// 大於0代表table.length的0.75倍
// -1代表正在初始化
// -N 代表有 -（N-1)個線程正在擴容
private transient volatile int sizeCtl;
// 擴容時候用到的記錄轉移索引
private transient volatile int transferIndex;
靜態方法
// 下面三個方法調用了Unsafe的一些操作內存的方法，用反射獲取Unsafe的成員變量theUnsafe可以做實驗
// 原子的獲取table的i位置的元素
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
// CAS機制替換i位置的元素
static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,Node<K,V> c, Node<K,V> v) {
return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}
CAS機制i位置元素賦值
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
}
2、ConcurrentHashMap使用示例
下面我演示一個普通的用法，然後第三部分借這個用法示例分析ConcurrentHashMap核心方法
public class MainTest {
public static void main(String[] args) {
ConcurrentHashMap<String,String> concurrentHashMap = new ConcurrentHashMap<>();
// 這裏是方便使得ConcurrentHashMap擴容觸發
for(int i=0;i<13;i++){
concurrentHashMap.put("name"+i,"fuhang");
}
concurrentHashMap.get("name1");
concurrentHashMap.remove("name1");
}
3、ConcurrentHashMap跟隨示例學原理
這裏借用我在記錄HashMap時候畫的table的簡易結構圖來說下ConcurrentHashMap的結構，兩者基本結構類似。
構造函數已經在上面貼出，這裏不再贅述。我直接從put()方法開始切入。
put相關方法
① put(K,V)
// 對外暴露的put方法，ConcurrentHashMap內部調用putVal()方法進行實際處理
public V put(K key, V value) {
return putVal(key, value, false);
}
// 實際的put方法，最後一個參數代表當舊值存在時候是否替換舊值
final V putVal(K key, V value, boolean onlyIfAbsent) {
// 在這裏可以看出ConcurrentHashMap中的key和value都不能爲空
// HashMap中的key可以爲空，爲空時候hash值爲0
if (key == null || value == null) throw new NullPointerException();
// 調用spread方法計算hash，後面分析
int hash = spread(key.hashCode());
// binCount記錄一個槽位中存在多少個node
int binCount = 0;
// 下面開始for循環將值放入table
for (Node<K,V>[] tab = table;;) {
// f ： 定位到的節點
// n ： table的長度
// i : hash%n算出的節點索引
// fh： 代表定位到的節點的hash
Node<K,V> f; int n, i, fh;
// 如果tab爲空或者長度爲0，那就初始化table，大多是初次調用put方法時候執行的
if (tab == null || (n = tab.length) == 0)
// initTable()初始化方法在後面分析
tab = initTable();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 如果定位到的槽位的node爲null，那麼直接CAS機制將key，value放入i位置
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)
// 如果定位到的節點的hash值爲MOVED（-1），則說明table正在擴容
// 調用helpTransfer方法協助擴容
tab = helpTransfer(tab, f);
else {
// 到此就說明沒擴容，定位到的f節點不爲空，說明有碰撞了
// 通過拉鍊法將當前節點放入鏈尾部
V oldVal = null;
// 首先對鏈的頭節點加鎖
synchronized (f) {
// 加鎖之後需要再次判斷i索引位置的節點是否爲此次循環中的節點
// 因爲可能在上一步判斷完成之後，另個線程執行擴容恰好移動到了i位置
// 那麼i位置的節點就由f變爲fwd了，所以加鎖之後需要再次判斷定位的節點
// 是否和之前一樣
if (tabAt(tab, i) == f) {
// 判斷fh的hash大於0
if (fh >= 0) {
// 設置節點計數器爲1
binCount = 1;
// 下面從頭結點向後遍歷
for (Node<K,V> e = f;; ++binCount) {
K ek;
// 如果i位置的鏈表中存在一個節點的key和
// 當前給的key值相等，!onlyIfAbsent爲真的情況下覆蓋舊值
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) {
// 如果 f 節點是一個樹節點，那就執行紅黑樹插入
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;
}
}
}
}
// 如果i位置的節點數量不爲0
if (binCount != 0) {
// 如果 i 位置的節點數量大於等於8，就嘗試將i位置的所有節點樹化
// 在treeifyBin內部還需要滿足table的長度>64才樹化
// 要不然就嘗試擴容
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
// 如果舊值存在，說明沒有新的節點創建
// 那麼久直接返回舊值，不需要程序再執行擴容檢測
if (oldVal != null)
return oldVal;
break;
}
}
}
// 這裏就是類似於HashMap中的resize()方法的作用
addCount(1L, binCount);
return null;
}
② spread(int h)
// ConcurrentHashMap中算hash的方法
// HASH_BIT : 0111 1111 1111 1111 1111 1111 1111 1111
static final int spread(int h) {
// 這裏和HashMap的比較多了一步
// 要將(h ^ (h >>> 16))的結果和HASH_BIT做與運算
// 這一步主要是爲了將(h ^ (h >>> 16))的最高位置0，也就是保持hash爲正數
// 因爲hash的正負值也代表不同的邏輯意義
return (h ^ (h >>> 16)) & HASH_BITS;
}
// 回顧下HashMap中的算Hash的方法
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
③ initTable()
這個方法一般是在第一次putVal時候調用，用來初始化table，使用sizeCtl來標誌初始化狀態，sizeCtl = -1表示正在初始化，初始化完成以後將sizeCtl設置成table容量的0.75倍，類似HashMap中的閾值作用。
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
// while循環進行判斷table是否初始化完成
while ((tab = table) == null || tab.length == 0) {
// 如果sizeCtl小於0，則讓出cup佔用權
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
// 要不然將將sizeCtl設置爲-1，標誌此時正在初始化
try {
// 這裏爲什麼要在做判斷容我思考下
if ((tab = table) == null || tab.length == 0) {
// 若sizeCtl>0(初始化ConcurrentHashMap傳入容量的情況) n=sc
// 要不然n=DEFAULT_CAPACITY (無參構造的情況)
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
// 創建Node數組，長度爲n
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
// sc設置爲0.75 * n，類似HashMap中的loadFactor*Cap
sc = n - (n >>> 2);
}
} finally {
// 將sizeCtl賦值爲sc
sizeCtl = sc;
}
break;
}
}
return tab;
}
④addCount(long x, int check)
// 這個方法類似於HashMap中的resize()
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
// 這裏先暫時不做分析，先記住if判斷中將s賦值爲baseCount+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();
}
// 如果check>=0
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
// while循環判斷擴容是否完成
// 當s（可以理解爲table中的元素數量）>sizeCtl（閾值）時候
// 且table！=null 且 table.length<MAXIMUM_CAPACITY時嘗試擴容
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
// 根據n也就是table.length算一個rs，這個操作相當於一個擴容前的標記
int rs = resizeStamp(n);
// 如果sc小於0，說明正在擴容
if (sc < 0) {
// 1、如果sc 絕對右移16位（相當於丟棄記錄擴容線程的後16位）不等於rs
// 說明擴容標記有變化，本次擴容和之前的不是同一個擴容
// 2、如果sc==rs+1 說明擴容結束，因爲sc+2是初始值，sc-1是擴容完成
// 3、如果sc == rs +MAX_RESIZER（1<<16）-1，說明擴容線程已到達最大
// 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;
// 要不然將將sc+1(擴容線程數量+1)，開始擴容
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
// sizeCtl不小於0，那就將sizeCtl設爲(rs << RESIZE_STAMP_SHIFT) + 2)
// 在這個時候sizeCtl值的前16位表示擴容開始前將容量大小用二進制表示時候
// 從左往右數第一個1之前0的個數，相當於封存下擴容前的場景。後16位表示
// 有多少線程正在擴容，設置成功後sizeCtl就變成負數了
// 這裏+2的操作就是當第一個線程擴容完成後會執行 rs-1操作，方便上面判斷
// 調用transfer方法開始擴容
transfer(tab, null);
// 統計table中的節點數量
s = sumCount();
}
}
}
⑤ transfer(Node<K,V>[] tab, Node<K,V>[] nextTab)
我在代碼分析裏面先介紹下transfer的邏輯，隨後會用一個容量爲16，sizeCtl爲12的map來添加12個元素，實際分析一次擴容做了什麼。
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
// n 爲原table的長度，stride記錄處理步長
int n = tab.length, stride;
// 計算步長
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
// 如果nexttab爲空則說明是第一次調用擴容
if (nextTab == null) { // initiating
try {
// 創建一個原表長度兩倍大的新表nt
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
// 將nt賦值給nextTabl
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;
return;
}
// 將nextTab賦值給ConcurrentHashMap的成員變量nextTable
// 將n賦值給ConcurrentHashMap的成員變量transferIndex
// 回想一下addCount()方法中當sc小於0時候的第一個if判斷
nextTable = nextTab;
transferIndex = n;
}
// 用nextn記錄新表的長度
int nextn = nextTab.length;
// 創建一個ForwardingNode ，這是Node的子類，內部有一個成員變量爲Node[] nextTable
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
// 這個標誌控制下面while循環
boolean advance = true;
// 擴容結束標誌
boolean finishing = false; // to ensure sweep before committing nextTab
// for循環進入
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
// 若advance爲真進入while循環做處理
while (advance) {
int nextIndex, nextBound;
// 若 --i>=bound 說明擴容執行完成
if (--i >= bound || finishing)
advance = false;
else if ((nextIndex = transferIndex) <= 0) {
// 如果nextIndex<=0則可以進行結束判斷了
// 退出while循環進行結束檢測
i = -1;
advance = false;
}
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
// 要不然在這裏將transferIndex更新下
// 記錄邊界值
// 記錄開始轉移的索引 i
// 將advance設爲false以便退出while循環進行下面操作
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
// 結束判斷
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
// 如果結束標記爲真
if (finishing) {
// 將成員變量nextTable設爲null
// 回想下addCount()中當sc小於0的if判斷
nextTable = null;
// 將成員變量table設爲nextTab
table = nextTab;
// 記錄sizeCtl爲0.75 * 2n
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 若沒結束，先用sc記錄sizeCtl的值，再將sizeCtl設爲sizeCtl-1
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
// 如果此時恢復到轉換前的值不相等，則直接返回，說明還有擴容線程在運行
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
// 要不然將finish和advance標誌設置爲true
finishing = advance = true;
// 將i賦值爲n是爲了能重新再進入此代碼塊
i = n; // recheck before commit
}
}
else if ((f = tabAt(tab, i)) == null)
// 如果擴容時候i位置的元素爲null 那就將其CAS設置爲fwd節點
// 若設置成功則advance爲true，方便進入上面while循環將i進行遞減
advance = casTabAt(tab, i, null, fwd);
else if ((fh = f.hash) == MOVED)
// 如果i位置節點的hash值爲MOVED，則說明是fwd節點
// 說明已經執行過擴容處理。將advance設爲true，進入while循環將i遞減
advance = true; // already processed
else {
// 要不然將f加鎖進行節點轉移
synchronized (f) {
// 這裏再次判斷i位置的節點還是不是f
// 因爲到這裏才加鎖進行操作，故多個線程可能同時執行到此
// 若其中一個線程瞬間加鎖完成f節點的轉移後釋放鎖
// 那麼其他線程進行下面判斷時候就失敗了
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
if (fh >= 0) {
// 這裏我會畫圖做個解釋，類似HashMap的操作
// ln代表在原位置不變的頭結點
// hn代表擴容後在i+n位置的頭結點
// 下面會有圖示舉例
int runBit = fh & n;
Node<K,V> lastRun = f;
// 標誌爲for循環1，方便圖示中解釋
for (Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
if (runBit == 0) {
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
// 標誌爲for循環2
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);
}
// 將nextTable i位置節點設置爲ln
// 將nextTabl i+n位置節點設爲hn
// 將原tab的 i位置設爲fwd節點表示已經轉移
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
else if (f instanceof TreeBin) {
// 如果fh<0 則先判斷下是不是紅黑樹樹根節點
// 若是則進行樹節點的轉移
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> lo = null, loTail = null;
TreeNode<K,V> hi = null, hiTail = null;
int lc = 0, hc = 0;
// 下面代碼類似HashMap
for (Node<K,V> e = t.first; e != null; e = e.next) {
int h = e.hash;
TreeNode<K,V> p = new TreeNode<K,V>
(h, e.key, e.val, null, null);
if ((h & n) == 0) {
if ((p.prev = loTail) == null)
lo = p;
else
loTail.next = p;
loTail = p;
++lc;
}
else {
if ((p.prev = hiTail) == null)
hi = p;
else
hiTail.next = p;
hiTail = p;
++hc;
}
}
// 如果高低位置有節點數量小於6的，就嘗試取消樹化
ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
(hc != 0) ? new TreeBin<K,V>(lo) : t;
hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
(lc != 0) ? new TreeBin<K,V>(hi) : t;
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
以上就是transfer函數的代碼分析，口述下過程就是：
1、先獲取當前table的長度記爲n，再根據CPU個數給線程分配步長，最小處理步長爲16
2、如果傳遞過來的nextTab爲null，則說明是第一個擴容線程，創建一個2n大小的nextTab，賦值給全局變量nextTable，並將n值賦值給全局變量transferIndex
3、使用nextn記錄新表長度(2n)，創建一個ForwardingNode節點，原table每一個槽位轉移完成都會暫時將槽位節點設置成ForwardingNode節點。
4、定義兩個boolean變量advance和finishing，一個控制while循環調整索引，一個標誌擴容是否結束
5、進入for循環開始擴容，首先進入advance控制的while循環對索引邊界進行設置
6、緊接着if判斷索引i是否滿足一些條件，若滿足進行結束判斷
7、若(6)不滿足的情況下，將原tab的 i 位置的節點賦值給f，判斷f是否爲空，若爲空的話，使用CAS機制將i位置的節點設爲ForwardingNode，並置advance爲CAS設置節點的結果。
8、若(7)不滿足的情況下，將f節點的hash值賦值給fh變量，若fh==MOVED(-1)，說明i位置節點已經在擴容過程中轉移完成，將advance設爲true，方便下一次循環執行
9、若(8)不滿足的情況下，說明f節點爲轉移，則使用synchronized先對f節點加鎖，然後判斷i位置的節點是否還是f節點，若是則進入 f 節點擴容
默認容量16，sizeCtl(閾值)爲12，添加第12個元素時候的流程圖
普通鏈表節點轉移示意圖
⑥ helpTransfer(Node<K,V>[] tab, Node<K,V> f)
這個方法主要是感知到其他線程正在擴容，然後協助擴容的邏輯。
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
// 如果tab不爲空，且f是ForwardingNode節點，且fwd節點的nextTab不爲空
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;
// 將擴容線程+1，調用transfer(tab,nextTab)協助擴容
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}
⑦ treeifyBin(Node<K,V>[] tab, int index)
當某次put鍵值後的binCount>=8時候調用此方法，此方法中繼續判斷table.length若小於64則繼續調用tryPresize()方法將table進行擴容。若table.length不小於64，則嘗試將 index索引位置的節點進行樹化
private final void treeifyBin(Node<K,V>[] tab, int index) {
Node<K,V> b; int n, sc;
if (tab != null) {
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
tryPresize(n << 1);
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
synchronized (b) {
if (tabAt(tab, index) == b) {
TreeNode<K,V> hd = null, tl = null;
for (Node<K,V> e = b; e != null; e = e.next) {
TreeNode<K,V> p =
new TreeNode<K,V>(e.hash, e.key, e.val,
null, null);
if ((p.prev = tl) == null)
hd = p;
else
tl.next = p;
tl = p;
}
setTabAt(tab, index, new TreeBin<K,V>(hd));
}
}
}
}
}
⑧ tryPresize(int size)
// 此處是當table.length<64時候會調用到的一個方法
private final void tryPresize(int size) {
// 如果size(n<<1) 大於最大容量的一半，則將c設爲最大容量
// 要不然將c設爲大於（size*1.5+1）的最小的2的整數次冪值
int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
tableSizeFor(size + (size >>> 1) + 1);
int sc;
while ((sc = sizeCtl) >= 0) {
Node<K,V>[] tab = table; int n;
// 下面這段代碼有待思考，以後再來補充註釋
if (tab == null || (n = tab.length) == 0) {
n = (sc > c) ? sc : c;
if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if (table == tab) {
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
}
}
else if (c <= sc || n >= MAXIMUM_CAPACITY)
break;
else if (tab == table) {
// 下面這段就是一個正常擴容邏輯，在這裏不再贅述
int rs = resizeStamp(n);
if (sc < 0) {
Node<K,V>[] nt;
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
}
}
}
get相關方法
ConcurrentHashMap的get方法基本和HashMap的get方法類似
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
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)
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;
}
總結
以上就是暫時看完源碼後對ConcurrentHashMap的理解，將理解用文字和圖的形式記錄下來，其中也有暫時沒想通的點，隨後想通後會回來繼續補充完善文章。
若文中有錯誤地方，還請大家不吝賜教