目錄
- 1. JDK 7 HashMap 并發死鏈
- 1.1.HashMap回顧
- 1.2.測驗代碼
- 1.3.死鏈復現
- 1.4.原始碼復現
- 1.5.小結
- 2. JDK 8 ConcurrentHashMap
- 2.1.重要屬性和內部類
- 2.2.重要屬性和內部類
- 2.3.懶惰初始化
- 2.4.get 流程
- 2.5.put 流程
- 2.6.size 計算流程
- 2.7.擴容
- 2.8.小結
- 3.JDK7 ConcurrentHashMap
- 3.1.構造器分析
- 3.2.put 流程
- 3.3.rehash 流程
- 3.4.get 流程
- 3.5.size 計算流程
1. JDK 7 HashMap 并發死鏈
1.1.HashMap回顧
關于HashMap的具體特性可以參看HashMap集合
HashMap是由陣列+鏈表構成的，鏈表用來解決哈希沖突的情況，
注意:在JDK8里，后加入鏈表的元素被放入到鏈表的尾部，在JDK7里，后加入鏈表的元素被返給到鏈表的頭部，這是死鏈產生的重要原因，
死鏈發生在擴容時，隨著陣列中的元素越來越多，鏈表的長度就會越來越長，這樣性能就會受到影響，所以在JDK7和JDK8里都會在陣列元素超過閾值時，即陣列長度的3/4,它會進行一次擴容，擴容會重新計算桶下標，就會擴容出來長度翻倍的陣列，然后會把鏈表中一個一個元素遷移到新的陣列中去，擴容以后，分布的更加均勻，鏈表的長度也縮短了，性能得到提升，但是在多執行緒環境下進行擴容，就會造成并發死鏈的問題，直接讓記憶體卡死，out of memory，
1.2.測驗代碼
注意
要在 JDK 7 下運行，否則擴容機制和 hash 的計算方法都變了
以下測驗代碼是精心準備的，不要隨便改動
public static void main(String[] args) {
// 測驗 java 7 中哪些數字的 hash 結果相等
System.out.println("長度為16時，桶下標為1的key");
//最終列印出來的值為1,16,35,50
for (int i = 0; i < 64; i++) {
if (hash(i) % 16 == 1) {
System.out.println(i);
}
}
System.out.println("長度為32時，桶下標為1的key");
//最終列印出來的值為1和35
for (int i = 0; i < 64; i++) {
if (hash(i) % 32 == 1) {
System.out.println(i);
}
}
// 1, 35, 16, 50 當大小為16時，它們在一個桶內,
//HashMap初始容量為16，當容量超過3/4時擴容
final HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
// 放 12 個元素
map.put(2, null);
map.put(3, null);
map.put(4, null);
map.put(5, null);
map.put(6, null);
map.put(7, null);
map.put(8, null);
map.put(9, null);
map.put(10, null);
map.put(16, null);
map.put(35, null);
map.put(1, null);
System.out.println("擴容前大小[main]:"+map.size());
new Thread() {
@Override
public void run() {
// 放第 13 個元素, 發生擴容
map.put(50, null);
System.out.println("擴容后大小[Thread-0]:"+map.size());
}
}.start();
new Thread() {
@Override
public void run() {
// 放第 13 個元素, 發生擴容
map.put(50, null);
System.out.println("擴容后大小[Thread-1]:"+map.size());
}
}.start();
}
final static int hash(Object k) {
int h = 0;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
1.3.死鏈復現
除錯工具使用 idea
在 HashMap 原始碼 590 行加斷點
//轉移元素，擴容時會呼叫該方法，來完成從舊的table到新的table元素遷移，結點不會創建，
void transfer(Entry[] newTable, boolean rehash) {
//下面一行是590行
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
int newCapacity = newTable.length;
斷點的條件如下，目的是讓 HashMap 在擴容為 32 時，并且執行緒為 Thread-0 或 Thread-1 時停下來
newTable.length==32 &&
(
Thread.currentThread().getName().equals("Thread-0")||
Thread.currentThread().getName().equals("Thread-1")
)
斷點暫停方式選擇 Thread，否則在除錯 Thread-0 時，Thread-1 無法恢復運行
??運行代碼，程式在預料的斷點位置停了下來，輸出
長度為16時，桶下標為1的key
1
16
35
50
長度為32時，桶下標為1的key
1
35
擴容前大小[main]:12
接下來進入擴容流程除錯
??在 HashMap 原始碼 594 行加斷點
Entry<K,V> next = e.next; // 593
if (rehash) // 594
// ...
這是為了觀察 e 節點和 next 節點的狀態，Thread-0 單步執行到 594 行，再 594 處再添加一個斷點（條件 Thread.currentThread().getName().equals(“Thread-0”)）
這時可以在 Variables 面板觀察到 e 和 next 變數，使用 view as -> Object 查看節點狀態
e (1)->(35)->(16)->null
next (35)->(16)->null
e是當前正要去遷移的結點，next是下一個結點，
擴容時，會把e和next結點改變，就會導致死鏈，
在 Threads 面板選中 Thread-1 恢復運行，可以看到控制臺輸出新的內容如下，Thread-1 擴容已完成，由于35是后進入的元素，所以35最侄訓插入在鏈表的頭部，
newTable[1] (35)->(1)->null
擴容后大小:13
這時 Thread-0 還停在 594 處， Variables 面板變數的狀態已經變化為
e (1)->null
next (35)->(1)->null
為什么呢，因為 Thread-1 擴容時鏈表也是后加入的元素放入鏈表頭，因此鏈表就倒過來了，但 Thread-1 雖然結果正確，但它結束后 Thread-0 還要繼續運行
接下來就可以單步除錯（F8）觀察死鏈的產生了
下一輪回圈到 594，將 e 搬遷到 newTable 鏈表頭
newTable[1] (1)->null
e (35)->(1)->null
next (1)->null
下一輪回圈到 594，將 e 搬遷到 newTable 鏈表頭
newTable[1] (35)->(1)->null
e (1)->null
next null
再看看原始碼
e.next = newTable[1];
// 這時 e (1,35)
// 而 newTable[1] (35,1)->(1,35) 因為是同一個物件
newTable[1] = e;
// 再嘗試將 e 作為鏈表頭, 死鏈已成
e = next;
// 雖然 next 是 null, 會進入下一個鏈表的復制, 但死鏈已經形成了
1.4.原始碼復現
HashMap 的并發死鏈發生在擴容時
// 將 table 遷移至 newTable
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
// 1 處
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
// 2 處
// 將新元素加入 newTable[i], 原 newTable[i] 作為新元素的 next
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
假設 map 中初始元素是
原始鏈表，格式：[下標] (key,next)
[1] (1,35)->(35,16)->(16,null)
執行緒 a 執行到 1 處 ，此時區域變數 e 為 (1,35)，而區域變數 next 為 (35,16) 執行緒 a 掛起
執行緒 b 開始執行
第一次回圈
[1] (1,null)
第二次回圈
[1] (35,1)->(1,null)
第三次回圈
[1] (35,1)->(1,null)
[17] (16,null)
切換回執行緒 a，此時區域變數 e 和 next 被恢復，參考沒變但內容變了：e 的內容被改為 (1,null)，而 next 的內
容被改為 (35,1) 并鏈向 (1,null)
第一次回圈
[1] (1,null)
第二次回圈，注意這時 e 是 (35,1) 并鏈向 (1,null) 所以 next 又是 (1,null)
[1] (35,1)->(1,null)
第三次回圈，e 是 (1,null)，而 next 是 null，但 e 被放入鏈表頭，這樣 e.next 變成了 35 （2 處）
[1] (1,35)->(35,1)->(1,35)
已經是死鏈了
1.5.小結
- 究其原因，是因為在多執行緒環境下使用了非執行緒安全的 map 集合，導致1和35回圈參考的問題，
- JDK 8 雖然將擴容演算法做了調整，不再將元素加入鏈表頭（而是保持與擴容前一樣的順序），但仍不意味著能夠在多執行緒環境下能夠安全擴容，還會出現其它問題（如擴容丟資料），
2. JDK 8 ConcurrentHashMap
2.1.重要屬性和內部類
// 默認為 0
// 當初始化時, 為 -1
// 當擴容時, 為 -(1 + 擴容執行緒數)
// 當初始化或擴容完成后，為 下一次的擴容的閾值大小，即容量的3/4
private transient volatile int sizeCtl;
// 整個 ConcurrentHashMap 就是一個 Node[],鏈表結構
static class Node<K,V> implements Map.Entry<K,V> {}
// hash 表
transient volatile Node<K,V>[] table;
// 擴容時的 新 hash 表
private transient volatile Node<K,V>[] nextTable;
// 擴容時如果某個 bin 遷移完畢, 用 ForwardingNode 作為舊 table bin 的頭結點
//即當某個下標已經處理完了，就加個fnode，讓其它執行緒知道這個下標處理過了，就不會再這上面操作了
//如果其他執行緒來get,它就知道要到新的表中get
static final class ForwardingNode<K,V> extends Node<K,V> {}
// 用在 compute 以及 computeIfAbsent 時, 用來占位, 計算完成后替換為普通 Node
static final class ReservationNode<K,V> extends Node<K,V> {}
// 作為 treebin 的頭節點, 存盤 root 和 first
//用紅黑樹的資料結構，提升效率，同時還會防止DOS攻擊
//DOS攻擊是指攻擊者會構造一大批一樣的哈希物件，來往Map中填充，造成性能直接下降，如果改成紅黑樹，也能從一定程度上避免此種攻擊，
//它有一個長度閾值，如果長度超過8，鏈表就會變成紅黑樹，轉換之前，會先嘗試擴容，如果紅黑樹元素個數小于6，又會轉換為鏈表，
//TreeBin作為紅黑樹頭結點，TreeNode作為紅黑樹結點
static final class TreeBin<K,V> extends Node<K,V> {}
// 作為 treebin 的節點, 存盤 parent, left, right
static final class TreeNode<K,V> extends Node<K,V> {}
這里要注意的點是ForwardingNode，擴容時如果某個 bin 遷移完畢, 用 ForwardingNode 作為舊 table bin 的頭結點，即擴容時當某個table下標已經處理完了，就加個ForwardingNode ，讓其它執行緒知道這個下標已經擴容過了，就不會再這上面操作了，如果其他執行緒來get,它就知道要到新的表中get，
TreeBin它有一個長度閾值，如果長度超過8，鏈表就會變成紅黑樹，轉換之前，會先嘗試擴容，如果紅黑樹元素個數小于6，又會轉換為鏈表，
sizeCtl當初始化和擴容時為負數
2.2.重要屬性和內部類
// 獲取 Node[] 中第 i 個 Node
static final <K, V> Node<K, V> tabAt(Node<K, V>[] tab, int i)
// cas 修改 Node[] 中第 i 個 Node 的值, c 為舊值, v 為新值
static final <K, V> boolean casTabAt(Node<K, V>[] tab, int i, Node<K, V> c, Node<K, V> v)
// 直接修改 Node[] 中第 i 個 Node 的值, v 為新值
static final <K, V> void setTabAt(Node<K, V>[] tab, int i, Node<K, V> v)
2.3.懶惰初始化
可以看到實作了懶惰初始化，在構造方法中僅僅計算了 table 的大小，以后在第一次使用時才會真正創建
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);
// tableSizeFor 仍然是保證計算的大小是 2^n, 即 16,32,64 ...
int cap = (size >= (long)MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
this.sizeCtl = cap;
}
initialCapacity初始容量，loadFactor負載因子(0.75)，concurrencyLevel并發度
底層默認初始容量為16
2.4.get 流程
整個get流程中沒有任何的鎖
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
// spread 方法能確保回傳結果是正數
int h = spread(key.hashCode()); //h成了put和get時真正用到的hash碼
//這里找到哈希嗎用到了按位與，其實就相當于取模運算，比取模運算效率要高，
//1.先找到哈希地址
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
// 2.如果頭結點已經是要查找的 key
if ((eh = e.hash) == h) {
//值相等也可以認為是同一個物件
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
// hash 為負數表示該 bin 在擴容中或是 treebin, 這時呼叫 find 方法來查找
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
// 正常遍歷鏈表, 用 equals 比較
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
2.5.put 流程
以下陣列簡稱（table），鏈表簡稱（bin）
public V put(K key, V value) {
return putVal(key, value, false);
}
// onlyIfAbsent 只有缺失才賦值，即如果為true只有第一次put這個鍵和值的時候，才會放入map，以后如果put相同的值就不管，如果是false，每次都會用新值覆寫舊值
final V putVal(K key, V value, boolean onlyIfAbsent) {
//普通HashMap允許有空鍵或值，concurrentHashMap不允許有空鍵或值
if (key == null || value == null) throw new NullPointerException();
// 其中 spread 方法會綜合高位低位, 具有更好的 hash 性
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
// f 是鏈表頭節點
// fh 是鏈表頭結點的 hash
// i 是鏈表在 table 中的下標
Node<K,V> f; int n, i, fh;
// 要創建 table，懶惰初始化
if (tab == null || (n = tab.length) == 0)
// 初始化 table 使用了 cas, 無需 synchronized 創建成功, 進入下一輪回圈
tab = initTable();
// 要創建鏈表頭節點
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 添加鏈表頭使用了 cas, 無需 synchronized
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break;
}
// 幫忙擴容
else if ((fh = f.hash) == MOVED)
// 幫忙之后, 進入下一輪回圈
tab = helpTransfer(tab, f);
else {
V oldVal = null;
// 鎖住鏈表頭節點
synchronized (f) {
// 再次確認鏈表頭節點沒有被移動
if (tabAt(tab, i) == f) {
// 鏈表
if (fh >= 0) {
binCount = 1;
// 遍歷鏈表
for (Node<K,V> e = f;; ++binCount) {
K ek;
// 找到相同的 key
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;
// 已經是最后的節點了, 新增 Node, 追加至鏈表尾
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;
// putTreeVal 會看 key 是否已經在樹中, 是, 則回傳對應的 TreeNode
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
// 釋放鏈表頭節點的鎖
}
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
// 如果鏈表長度 >= 樹化閾值(8), 進行鏈表轉為紅黑樹
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
// 增加 size 計數
addCount(1L, binCount);
return null;
}
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0)
Thread.yield();
// 嘗試將 sizeCtl 設定為 -1（表示初始化 table）
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
// 獲得鎖, 創建 table, 這時其它執行緒會在 while() 回圈中 yield 直至 table 創建
try {
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
// check 是之前 binCount 的個數
private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
if (
// 已經有了 counterCells, 向 cell 累加
(as = counterCells) != null ||
// 還沒有, 向 baseCount 累加
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)
) {
CounterCell a; long v; int m;
boolean uncontended = true;
if (
// 還沒有 counterCells
as == null || (m = as.length - 1) < 0 ||
// 還沒有 cell
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
// cell cas 增加計數失敗
!(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
) {
// 創建累加單元陣列和cell, 累加重試
fullAddCount(x, uncontended);
return;
}
if (check <= 1)
return;
// 獲取元素個數
s = sumCount();
}
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);
if (sc < 0) {
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
// newtable 已經創建了，幫忙擴容
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
// 需要擴容，這時 newtable 未創建
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
s = sumCount();
}
}
}
注意點：
1.普通HashMap允許有空鍵或值，concurrentHashMap不允許有空鍵或值
2.初始化 table和創建鏈表頭 使用了 cas, 無需 synchronized 創建成功, 進入下一輪回圈，只有一個執行緒才會成功，
3.只有發生了桶下標沖突的時候，才會加鎖，使用synchronized,而且只對通的鏈表的頭結點進行加鎖，
4.addcount方法也會使用cas來維護執行緒安全，
5.1.8版本的時候，它是懶惰初始化的，在put之前，會先判斷是否是空表，如果是空表，就是創建新的哈希表，底層用cas來保證同一時刻不會有多個執行緒來創建哈希表，
6.put的流程.
- 如果是新表，執行初始化表的操作，初始化表用CAS來保證執行緒安全，
- 如果是要創建鏈表頭結點，那么就用cas保證執行緒安全性來創建鏈表頭結點.
- 如果有其他執行緒正在擴容，那么就可以幫助其它執行緒擴容，
- 如果桶下標發生沖突，此時才有必要加鎖，使用synchronized對鏈表的頭結點進行加鎖，進入到這個else陳述句中，如果是鏈表，我們遍歷鏈表，如果找到相同的key，就讓新的value覆寫舊的value，如果沒有找到，就追加到鏈表尾，如果結點的哈希碼小于0，進一步判斷是不是紅黑樹，如果是紅黑樹，就用紅黑樹的添加方法來put.
2.6.size 計算流程
size 計算實際發生在 put，remove 改變集合元素的操作之中
- 沒有競爭發生，向 baseCount 累加計數
- 有競爭發生，新建 counterCells，向其中的一個 cell 累加計數
- counterCells 初始有兩個 cell
- 如果計數競爭比較激烈，會創建新的 cell 來累加計數
public int size() {
long n = sumCount();
return ((n < 0L) ? 0 :
(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
(int)n);
}
final long sumCount() {
CounterCell[] as = counterCells; CounterCell a;
// 將 baseCount 計數與所有 cell 計數累加
long sum = baseCount;
if (as != null) {
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
return sum;
}
2.7.擴容
關于ConcurrentHashMap以及HashMap更加詳細的介紹請參考深入理解HashMap+ConcurrrentHashMap擴容的原理
2.8.小結
Java 8 陣列（Node） +（ 鏈表 Node | 紅黑樹 TreeNode ） 以下陣列簡稱（table），鏈表簡稱（bin）
初始化，使用 cas 來保證并發安全，懶惰初始化 table
樹化，當 table.length < 64 時，先嘗試擴容，超過 64 時，并且 bin.length > 8 時，會將鏈表樹化，樹化程序會用 synchronized 鎖住鏈表頭
put，如果該 bin 尚未創建，只需要使用 cas 創建 bin；如果已經有了，鎖住鏈表頭進行后續 put 操作，元素添加至 bin 的尾部
get，無鎖操作僅需要保證可見性，擴容程序中 get 操作拿到的是 ForwardingNode 它會讓 get 操作在新table 進行搜索
擴容，擴容時以 bin 為單位進行，需要對 bin 進行 synchronized，但這時妙的是其它競爭執行緒也不是無事可做，它們會幫助把其它 bin 進行擴容，擴容時平均只有 1/6 的節點會把復制到新 table 中
size，元素個數保存在 baseCount 中，并發時的個數變動保存在 CounterCell[] 當中，最后統計數量時累加即可
3.JDK7 ConcurrentHashMap
它維護了一個 segment 陣列，每個 segment 對應一把鎖
它集成自Reentranlock
優點：如果多個執行緒訪問不同的 segment，實際是沒有沖突的，這與 jdk8 中是思想類似的，JDK8中是把每個鎖加在鏈表頭，
缺點：Segments 陣列默認大小為16，這個容量初始化指定后就不能改變了，并且不是懶惰初始化，
3.1.構造器分析
public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (concurrencyLevel > MAX_SEGMENTS)
concurrencyLevel = MAX_SEGMENTS;
// ssize 必須是 2^n, 即 2, 4, 8, 16 ... 表示了 segments 陣列的大小
int sshift = 0;
int ssize = 1;
while (ssize < concurrencyLevel) {
++sshift;
ssize <<= 1;
}
// segmentShift 默認是 32 - 4 = 28
this.segmentShift = 32 - sshift;
// segmentMask 默認是 15 即 0000 0000 0000 1111
this.segmentMask = ssize - 1;
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
int c = initialCapacity / ssize;
if (c * ssize < initialCapacity)
++c;
int cap = MIN_SEGMENT_TABLE_CAPACITY;
while (cap < c)
cap <<= 1;
// 創建 segments and segments[0]
Segment<K,V> s0 =
new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
(HashEntry<K,V>[])new HashEntry[cap]);
//根據指定的大小創建初始化陣列，沒有根據實際情況擴容
Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
this.segments = ss;
}
創建segment[0],下標為0的元素內部又是hashEntry，hashEntry才對應著真正的哈希表，每個segment對應一個小的哈希表，每個hashEntry里面，又是陣列+鏈表的結構
Segment<K,V> s0 =
new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
(HashEntry<K,V>[])new HashEntry[cap]);
將來不同的執行緒來了，訪問不同的segment，則鎖的hashEntry不一樣，
可以看到 ConcurrentHashMap 沒有實作懶惰初始化，空間占用不友好
其中 this.segmentShift 和 this.segmentMask 的作用是決定將 key 的 hash 結果匹配到哪個 segment，
?例如，根據某一 hash 值求 segment 位置，先將高位向低位移動 this.segmentShift 位，
?這里假設segment實際大小為16，segmentShift 默認是 32 - 4 = 28，segmentMask 默認是 15 即 0000 0000 0000 1111(前面28位為0，后面4位為1)
結果再與 this.segmentMask 做位于運算，最終得到 1010 即下標為 10 的 segment
3.2.put 流程
public V put(K key, V value) {
Segment<K,V> s;
if (value == null)
throw new NullPointerException();
int hash = hash(key);
// 計算出 segment 下標
int j = (hash >>> segmentShift) & segmentMask;
// 獲得 segment 物件, 判斷是否為 null, 是則創建該 segment
if ((s = (Segment<K,V>)UNSAFE.getObject
(segments, (j << SSHIFT) + SBASE)) == null) {
// 這時不能確定是否真的為 null, 因為其它執行緒也發現該 segment 為 null,
// 因此在 ensureSegment 里用 cas 方式保證該 segment 安全性
s = ensureSegment(j);
}
// 進入 segment 的put 流程
return s.put(key, hash, value, false);
}
segment 繼承了可重入鎖（ReentrantLock），它的 put 方法為
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
// 嘗試加鎖
HashEntry<K,V> node = tryLock() ? null :
// 如果不成功, 進入 scanAndLockForPut 流程
// 如果是多核 cpu 最多 tryLock 64 次, 進入 lock 流程(很大幾率被阻塞住了)
// 在嘗試期間, 還可以順便看該節點在鏈表中有沒有, 如果沒有順便創建出來
scanAndLockForPut(key, hash, value);
// 執行到這里 segment 已經被成功加鎖, 可以安全執行
V oldValue;
try {
//每個segment是由一個hash陣列組成，即小的哈希表
HashEntry<K,V>[] tab = table;
//求得桶下標
int index = (tab.length - 1) & hash;
HashEntry<K,V> first = entryAt(tab, index);
for (HashEntry<K,V> e = first;;) {
if (e != null) {
// 更新
K k;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
oldValue = e.value;
if (!onlyIfAbsent) {
e.value = value;
++modCount;
}
break;
}
e = e.next;
}
else {
// 新增
// 1) 之前等待鎖時, node 已經被創建, next 指向鏈表頭
if (node != null)
node.setNext(first);
else
// 2) 創建新 node
node = new HashEntry<K,V>(hash, key, value, first);
int c = count + 1;
// 3) 擴容
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
rehash(node);
else
// 將 node 作為鏈表頭
setEntryAt(tab, index, node);
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
unlock();
}
return oldValue;
}
3.3.rehash 流程
發生在 put 中，因為此時已經獲得了鎖，因此 rehash 時不需要考慮執行緒安全
private void rehash(HashEntry<K,V> node) {
HashEntry<K,V>[] oldTable = table;
int oldCapacity = oldTable.length;
int newCapacity = oldCapacity << 1; //容量乘以2
threshold = (int)(newCapacity * loadFactor);
HashEntry<K,V>[] newTable =
(HashEntry<K,V>[]) new HashEntry[newCapacity];
int sizeMask = newCapacity - 1;
//注意，把舊的哈希表中的值搬遷到新的哈希表中，有的結點是搬遷過去的，有的會創建新的，
for (int i = 0; i < oldCapacity ; i++) {
HashEntry<K,V> e = oldTable[i];
if (e != null) {
HashEntry<K,V> next = e.next;
int idx = e.hash & sizeMask;
if (next == null) // Single node on list
newTable[idx] = e;
else { // Reuse consecutive sequence at same slot
HashEntry<K,V> lastRun = e;
int lastIdx = idx;
// 過一遍鏈表, 盡可能把 rehash 后 idx 不變的節點重用
for (HashEntry<K,V> last = next;
last != null;
last = last.next) {
int k = last.hash & sizeMask;
if (k != lastIdx) {
lastIdx = k;
lastRun = last;
}
}
newTable[lastIdx] = lastRun;
// 剩余節點需要新建
for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
V v = p.value;
int h = p.hash;
int k = h & sizeMask;
HashEntry<K,V> n = newTable[k];
newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
}
}
}
}
// 擴容完成, 才加入新的節點
int nodeIndex = node.hash & sizeMask; // add the new node
node.setNext(newTable[nodeIndex]);
newTable[nodeIndex] = node;
// 替換為新的 HashEntry table
table = newTable;
}
3.4.get 流程
get 時并未加鎖，用了 UNSAFE 方法保證了可見性，擴容程序中，get 先發生就從舊表取內容，get 后發生就從新表取內容
public V get(Object key) {
Segment<K,V> s; // manually integrate access methods to reduce overhead
HashEntry<K,V>[] tab;
int h = hash(key);
// u 為 segment 物件在陣列中的偏移量
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
// s 即為 segment
if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {
for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
e != null; e = e.next) {
K k;
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
return null;
}
3.5.size 計算流程
計算元素個數前，先不加鎖計算兩次，如果前后兩次結果如一樣，認為個數正確回傳
如果不一樣，進行重試，重試次數超過 3，將所有 segment 鎖住，重新計算個數回傳
public int size() {
// Try a few times to get accurate count. On failure due to
// continuous async changes in table, resort to locking.
final Segment<K,V>[] segments = this.segments;
int size;
boolean overflow; // true if size overflows 32 bits
long sum; // sum of modCounts
long last = 0L; // previous sum
int retries = -1; // first iteration isn't retry
try {
for (;;) {
if (retries++ == RETRIES_BEFORE_LOCK) {
// 超過重試次數, 需要創建所有 segment 并加鎖
for (int j = 0; j < segments.length; ++j)
ensureSegment(j).lock(); // force creation
}
sum = 0L;
size = 0;
overflow = false;
for (int j = 0; j < segments.length; ++j) {
Segment<K,V> seg = segmentAt(segments, j);
if (seg != null) {
sum += seg.modCount;
int c = seg.count;
if (c < 0 || (size += c) < 0)
overflow = true;
}
}
if (sum == last)
break;
last = sum;
}
} finally {
if (retries > RETRIES_BEFORE_LOCK) {
for (int j = 0; j < segments.length; ++j)
segmentAt(segments, j).unlock();
}
}
return overflow ? Integer.MAX_VALUE : size;
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/257446.html
標籤：java
上一篇：Java新手基礎（隨筆）