溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
小編給大家分享一下Java源碼解析之ConcurrentHashMap的示例分析，希望大家閱讀完這篇文章之后都有所收獲，下面讓我們一起去探討吧！
早期 ConcurrentHashMap，其實現是基于：
分離鎖，也就是將內部進行分段（Segment），里面則是 HashEntry 的數組，和 HashMap 類似，哈希相同的條目也是以鏈表形式存放。
HashEntry 內部使用 volatile 的 value 字段來保證可見性，也利用了不可變對象的機制以改進利用 Unsafe 提供的底層能力，比如 volatile access，去直接完成部分操作，以最優化性能，畢竟 Unsafe 中的很多操作都是 JVM intrinsic 優化過的。
在進行并發操作的時候，只需要鎖定相應段，這樣就有效避免了類似 Hashtable 整體同步的問題，大大提高了性能。
Put操作
通過二次哈希避免哈希沖突，然后以 Unsafe 調用方式，直接獲取相應的 Segment，然后進行線程安全的 put 操作
public V put(K key, V value) {
Segment<K,V> s;
if (value == null)
throw new NullPointerException();
// 二次哈希，以保證數據的分散性，避免哈希沖突
int hash = hash(key.hashCode());
int j = (hash >>> segmentShift) & segmentMask;
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
s = ensureSegment(j);
return s.put(key, hash, value, false);
}其核心邏輯實現在下面的內部方法中：
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
// scanAndLockForPut 會去查找是否有 key 相同 Node
// 無論如何，確保獲取鎖
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
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;
// 更新已有 value...
}
else {
// 放置 HashEntry 到特定位置，如果超過閾值，進行 rehash
// ...
}
}
} finally {
unlock();
}
return oldValue;
}在寫的時候：
ConcurrentHashMap 會獲取再入鎖，以保證數據一致性，Segment 本身就是基于 ReentrantLock 的擴展實現，所以，在并發修改期間，相應 Segment 是被鎖定的。
在最初階段，進行重復性的掃描，以確定相應 key 值是否已經在數組里面，進而決定是更新還是放置操作。
在 ConcurrentHashMap 中解決擴容的問題，不是整體的擴容，而是單獨對 Segment 進行擴容。
為了減少鎖定segment的開銷，ConcurrentHashMap 的實現是通過重試機制（RETRIES_BEFORE_LOCK，指定重試次數 2），來試圖獲得可靠值。如果沒有監控到發生變化（通過對比 Segment.modCount），就直接返回，否則獲取鎖進行操作。
機制在Java 8 上的變化：
總體結構上，它的內部存儲與HashMap 結構非常相似，同樣是大的桶（bucket）數組，然后內部也是一個個所謂的鏈表結構（bin），同步的粒度要更細致一些。
其內部仍然有 Segment 定義，但僅僅是為了保證序列化時的兼容性而已，不再有任何結構上的用處。
因為不再使用 Segment，初始化操作大大簡化，修改為 lazy-load 形式，這樣可以有效避免初始開銷。
數據存儲利用 volatile 來保證可見性。
使用 CAS (Compare And Swap)等操作，在特定場景進行無鎖并發操作。
使用 Unsafe、LongAdder 之類底層手段，進行極端情況的優化。
看看在java8上的put操作
final V putVal(K key, V value, boolean onlyIfAbsent) { if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh; K fk; V fv;
if (tab == null || (n = tab.length) == 0)
tab = initTable();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 利用 CAS 去進行無鎖線程安全操作，如果 bin 是空的
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
break;
}
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else if (onlyIfAbsent // 不加鎖，進行檢查
&& fh == hash
&& ((fk = f.key) == key || (fk != null && key.equals(fk)))
&& (fv = f.val) != null)
return fv;
else {
V oldVal = null;
synchronized (f) {
// 細粒度的同步修改操作...
}
}
// Bin 超過閾值，進行樹化
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}初始化操作實現在 initTable 里面，這是一個典型的 CAS 使用場景，利用 volatile 的 sizeCtl 作為互斥手段：如果發現競爭性的初始化，就 spin 在那里，等待條件恢復；否則利用 CAS 設置排他標志。如果成功則進行初始化；否則重試。
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
// 如果發現沖突，進行 spin 等待
if ((sc = sizeCtl) < 0)
Thread.yield();
// CAS 成功返回 true，則進入真正的初始化邏輯
else if (U.compareAndSetInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}當 bin 為空時，同樣是沒有必要鎖定，也是以 CAS 操作去放置。
看完了這篇文章，相信你對“Java源碼解析之ConcurrentHashMap的示例分析”有了一定的了解，如果想了解更多相關知識，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
