早期 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的文章就介紹到這了,更多相關Java ConcurrentHashMap內容請搜索好吧啦網以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持好吧啦網！