Java concurrency集合之ConcurrentHashMap_動力節(jié)點Java學院整理
ConcurrentHashMap介紹
ConcurrentHashMap是線程安全的哈希表。HashMap, Hashtable, ConcurrentHashMap之間的關聯如下：
HashMap是非線程安全的哈希表，常用于單線程程序中。
Hashtable是線程安全的哈希表，它是通過synchronized來保證線程安全的；即，多線程通過同一個“對象的同步鎖”來實現并發(fā)控制。Hashtable在線程競爭激烈時，效率比較低(此時建議使用ConcurrentHashMap)！因為當一個線程訪問Hashtable的同步方法時，其它線程就訪問Hashtable的同步方法時，可能會進入阻塞狀態(tài)。
ConcurrentHashMap是線程安全的哈希表，它是通過“鎖分段”來保證線程安全的。ConcurrentHashMap將哈希表分成許多片段(Segment)，每一個片段除了保存哈希表之外，本質上也是一個“可重入的互斥鎖”(ReentrantLock)。多線程對同一個片段的訪問，是互斥的；但是，對于不同片段的訪問，卻是可以同步進行的。
ConcurrentHashMap原理和數據結構
要想搞清ConcurrentHashMap，必須先弄清楚它的數據結構：
(01) ConcurrentHashMap繼承于AbstractMap抽象類。
(02) Segment是ConcurrentHashMap中的內部類，它就是ConcurrentHashMap中的“鎖分段”對應的存儲結構。
ConcurrentHashMap與Segment是組合關系，1個ConcurrentHashMap對象包含若干個Segment對象。在代碼中，這表現為ConcurrentHashMap類中存在“Segment數組”成員。
(03) Segment類繼承于ReentrantLock類，所以Segment本質上是一個可重入的互斥鎖。
(04) HashEntry也是ConcurrentHashMap的內部類，是單向鏈表節(jié)點，存儲著key-value鍵值對。Segment與HashEntry是組合關系，Segment類中存在“HashEntry數組”成員，“HashEntry數組”中的每個HashEntry就是一個單向鏈表。
對于多線程訪問對一個“哈希表對象”競爭資源，Hashtable是通過一把鎖來控制并發(fā)；而ConcurrentHashMap則是將哈希表分成許多片段，對于每一個片段分別通過一個互斥鎖來控制并發(fā)。ConcurrentHashMap對并發(fā)的控制更加細膩，它也更加適應于高并發(fā)場景！
ConcurrentHashMap函數列表
// 創(chuàng)建一個帶有默認初始容量 (16)、加載因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。 ConcurrentHashMap() // 創(chuàng)建一個帶有指定初始容量、默認加載因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。 ConcurrentHashMap(int initialCapacity) // 創(chuàng)建一個帶有指定初始容量、加載因子和默認 concurrencyLevel (16) 的新的空映射。 ConcurrentHashMap(int initialCapacity, float loadFactor) // 創(chuàng)建一個帶有指定初始容量、加載因子和并發(fā)級別的新的空映射。 ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) // 構造一個與給定映射具有相同映射關系的新映射。 ConcurrentHashMap(Map<? extends K,? extends V> m) // 從該映射中移除所有映射關系 void clear() // 一種遺留方法，測試此表中是否有一些與指定值存在映射關系的鍵。 boolean contains(Object value) // 測試指定對象是否為此表中的鍵。 boolean containsKey(Object key) // 如果此映射將一個或多個鍵映射到指定值，則返回 true。 boolean containsValue(Object value) // 返回此表中值的枚舉。 Enumeration<V> elements() // 返回此映射所包含的映射關系的 Set 視圖。 Set<Map.Entry<K,V>> entrySet() // 返回指定鍵所映射到的值，如果此映射不包含該鍵的映射關系，則返回 null。 V get(Object key) // 如果此映射不包含鍵-值映射關系，則返回 true。 boolean isEmpty() // 返回此表中鍵的枚舉。 Enumeration<K> keys() // 返回此映射中包含的鍵的 Set 視圖。 Set<K> keySet() // 將指定鍵映射到此表中的指定值。 V put(K key, V value) // 將指定映射中所有映射關系復制到此映射中。 void putAll(Map<? extends K,? extends V> m) // 如果指定鍵已經不再與某個值相關聯，則將它與給定值關聯。 V putIfAbsent(K key, V value) // 從此映射中移除鍵（及其相應的值）。 V remove(Object key) // 只有目前將鍵的條目映射到給定值時，才移除該鍵的條目。 boolean remove(Object key, Object value) // 只有目前將鍵的條目映射到某一值時，才替換該鍵的條目。 V replace(K key, V value) // 只有目前將鍵的條目映射到給定值時，才替換該鍵的條目。 boolean replace(K key, V oldValue, V newValue) // 返回此映射中的鍵-值映射關系數。 int size() // 返回此映射中包含的值的 Collection 視圖。 Collection<V> values()
下面從ConcurrentHashMap的創(chuàng)建，獲取，添加，刪除這4個方面對ConcurrentHashMap進行分析。
1 創(chuàng)建
下面以ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel)來進行說明。
@SuppressWarnings("unchecked")
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
// 參數有效性判斷
if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
// concurrencyLevel是“用來計算segments的容量”
if (concurrencyLevel > MAX_SEGMENTS)
concurrencyLevel = MAX_SEGMENTS;
int sshift = 0;
int ssize = 1;
// ssize=“大于或等于concurrencyLevel的最小的2的N次方值”
while (ssize < concurrencyLevel) {
++sshift;
ssize <<= 1;
}
// 初始化segmentShift和segmentMask
this.segmentShift = 32 - sshift;
this.segmentMask = ssize - 1;
// 哈希表的初始容量
// 哈希表的實際容量=“segments的容量” x “segments中數組的長度”
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// “哈希表的初始容量” / “segments的容量”
int c = initialCapacity / ssize;
if (c * ssize < initialCapacity)
++c;
// cap就是“segments中的HashEntry數組的長度”
int cap = MIN_SEGMENT_TABLE_CAPACITY;
while (cap < c)
cap <<= 1;
// segments
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;
}
說明：
(01) 前面我們說過，ConcurrentHashMap采用了“鎖分段”技術；在代碼中，它通過“segments數組”對象來保存各個分段。segments的定義如下：
final Segment<K,V>[] segments;
concurrencyLevel的作用就是用來計算segments數組的容量大小。先計算出“大于或等于concurrencyLevel的最小的2的N次方值”，然后將其保存為“segments的容量大小(ssize)”。
(02) initialCapacity是哈希表的初始容量。需要注意的是，哈希表的實際容量=“segments的容量” x “segments中數組的長度”。
(03) loadFactor是加載因子。它是哈希表在其容量自動增加之前可以達到多滿的一種尺度。
ConcurrentHashMap的構造函數中涉及到的非常重要的一個結構體，它就是Segment。下面看看Segment的聲明：
static final class Segment<K,V> extends ReentrantLock implements Serializable {
...
transient volatile HashEntry<K,V>[] table;
// threshold閾，是哈希表在其容量自動增加之前可以達到多滿的一種尺度。
transient int threshold;
// loadFactor是加載因子
final float loadFactor;
Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
this.loadFactor = lf;
this.threshold = threshold;
this.table = tab;
}
...
}
說明：Segment包含HashEntry數組，HashEntry保存了哈希表中的鍵值對。
此外，還需要說明的Segment繼承于ReentrantLock。這意味著，Segment本質上就是可重入的互斥鎖。
HashEntry的源碼如下：
static final class HashEntry<K,V> {
final int hash; // 哈希值
final K key; // 鍵
volatile V value; // 值
volatile HashEntry<K,V> next; // 下一個HashEntry節(jié)點
HashEntry(int hash, K key, V value, HashEntry<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
..
}
說明：和HashMap的節(jié)點一樣，HashEntry也是鏈表。這就說明，ConcurrentHashMap是鏈式哈希表，它是通過“拉鏈法”來解決哈希沖突的。
2 獲取
下面以get(Object key)為例，對ConcurrentHashMap的獲取方法進行說明。
public V get(Object key) {
Segment<K,V> s; // manually integrate access methods to reduce overhead
HashEntry<K,V>[] tab;
int h = hash(key);
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
// 獲取key對應的Segment片段。
// 如果Segment片段不為null，則在“Segment片段的HashEntry數組中”中找到key所對應的HashEntry列表；
// 接著遍歷該HashEntry鏈表，找到于key-value鍵值對對應的HashEntry節(jié)點。
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;
}
說明：get(Object key)的作用是返回key在ConcurrentHashMap哈希表中對應的值。
它首先根據key計算出來的哈希值，獲取key所對應的Segment片段。
如果Segment片段不為null，則在“Segment片段的HashEntry數組中”中找到key所對應的HashEntry列表。Segment包含“HashEntry數組”對象，而每一個HashEntry本質上是一個單向鏈表。
接著遍歷該HashEntry鏈表，找到于key-value鍵值對對應的HashEntry節(jié)點。
下面是hash()的源碼
private int hash(Object k) {
int h = hashSeed;
if ((0 != h) && (k instanceof String)) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
// Spread bits to regularize both segment and index locations,
// using variant of single-word Wang/Jenkins hash.
h += (h << 15) ^ 0xffffcd7d;
h ^= (h >>> 10);
h += (h << 3);
h ^= (h >>> 6);
h += (h << 2) + (h << 14);
return h ^ (h >>> 16);
}
3 增加
下面以put(K key, V value)來對ConcurrentHashMap中增加鍵值對來進行說明。
public V put(K key, V value) {
Segment<K,V> s;
if (value == null)
throw new NullPointerException();
// 獲取key對應的哈希值
int hash = hash(key);
int j = (hash >>> segmentShift) & segmentMask;
// 如果找不到該Segment，則新建一個。
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);
}
說明：
(01) put()根據key獲取對應的哈希值，再根據哈希值找到對應的Segment片段。如果Segment片段不存在，則新增一個Segment。
(02) 將key-value鍵值對添加到Segment片段中。
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
// tryLock()獲取鎖，成功返回true，失敗返回false。
// 獲取鎖失敗的話，則通過scanAndLockForPut()獲取鎖，并返回”要插入的key-value“對應的”HashEntry鏈表“。
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
// tab代表”當前Segment中的HashEntry數組“
HashEntry<K,V>[] tab = table;
// 根據”hash值“獲取”HashEntry數組中對應的HashEntry鏈表“
int index = (tab.length - 1) & hash;
HashEntry<K,V> first = entryAt(tab, index);
for (HashEntry<K,V> e = first;;) {
// 如果”HashEntry鏈表中的當前HashEntry節(jié)點“不為null，
if (e != null) {
K k;
// 當”要插入的key-value鍵值對“已經存在于”HashEntry鏈表中“時，先保存原有的值。
// 若”onlyIfAbsent“為true，即”要插入的key不存在時才插入”，則直接退出；
// 否則，用新的value值覆蓋原有的原有的值。
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 {
// 如果node非空，則將first設置為“node的下一個節(jié)點”。
// 否則，新建HashEntry鏈表
if (node != null)
node.setNext(first);
else
node = new HashEntry<K,V>(hash, key, value, first);
int c = count + 1;
// 如果添加key-value鍵值對之后，Segment中的元素超過閾值(并且，HashEntry數組的長度沒超過限制)，則rehash；
// 否則，直接添加key-value鍵值對。
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
rehash(node);
else
setEntryAt(tab, index, node);
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
// 釋放鎖
unlock();
}
return oldValue;
}
說明：
put()的作用是將key-value鍵值對插入到“當前Segment對應的HashEntry中”，在插入前它會獲取Segment對應的互斥鎖，插入后會釋放鎖。具體的插入過程如下：
(01) 首先根據“hash值”獲取“當前Segment的HashEntry數組對象”中的“HashEntry節(jié)點”，每個HashEntry節(jié)點都是一個單向鏈表。
(02) 接著，遍歷HashEntry鏈表。
若在遍歷HashEntry鏈表時，找到與“要key-value鍵值對”對應的節(jié)點，即“要插入的key-value鍵值對”的key已經存在于HashEntry鏈表中。則根據onlyIfAbsent進行判斷，若onlyIfAbsent為true，即“當要插入的key不存在時才插入”，則不進行插入，直接返回；否則，用新的value值覆蓋原始的value值，然后再返回。
若在遍歷HashEntry鏈表時，沒有找到與“要key-value鍵值對”對應的節(jié)點。當node!=null時，即在scanAndLockForPut()獲取鎖時，已經新建了key-value對應的HashEntry節(jié)點，則”將HashEntry添加到Segment中“；否則，新建key-value對應的HashEntry節(jié)點，然后再“將HashEntry添加到Segment中”。 在”將HashEntry添加到Segment中“前，會判斷是否需要rehash。如果在添加key-value鍵值之后，容量會超過閾值，并且HashEntry數組的長度沒有超過限制，則進行rehash；否則，直接通過setEntryAt()將key-value鍵值對添加到Segment中。
在介紹rehash()和setEntryAt()之前，我們先看看自旋函數scanAndLockForPut()。下面是它的源碼：
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
// 第一個HashEntry節(jié)點
HashEntry<K,V> first = entryForHash(this, hash);
// 當前的HashEntry節(jié)點
HashEntry<K,V> e = first;
HashEntry<K,V> node = null;
// 重復計數(自旋計數器)
int retries = -1; // negative while locating node
// 查找”key-value鍵值對“在”HashEntry鏈表上對應的節(jié)點“；
// 若找到的話，則不斷的自旋；在自旋期間，若通過tryLock()獲取鎖成功則返回；否則自旋MAX_SCAN_RETRIES次數之后，強制獲取”鎖“并退出。
// 若沒有找到的話，則新建一個HashEntry鏈表。然后不斷的自旋。
// 此外，若在自旋期間，HashEntry鏈表的表頭發(fā)生變化；則重新進行查找和自旋工作！
while (!tryLock()) {
HashEntry<K,V> f; // to recheck first below
// 1. retries<0的處理情況
if (retries < 0) {
// 1.1 如果當前的HashEntry節(jié)點為空(意味著，在該HashEntry鏈表上上沒有找到”要插入的鍵值對“對應的節(jié)點)，而且node=null；則新建HashEntry鏈表。
if (e == null) {
if (node == null) // speculatively create node
node = new HashEntry<K,V>(hash, key, value, null);
retries = 0;
}
// 1.2 如果當前的HashEntry節(jié)點是”要插入的鍵值對在該HashEntry上對應的節(jié)點“，則設置retries=0
else if (key.equals(e.key))
retries = 0;
// 1.3 設置為下一個HashEntry。
else
e = e.next;
}
// 2. 如果自旋次數超過限制，則獲取“鎖”并退出
else if (++retries > MAX_SCAN_RETRIES) {
lock();
break;
}
// 3. 當“嘗試了偶數次”時，就獲取“當前Segment的第一個HashEntry”，即f。
// 然后，通過f!=first來判斷“當前Segment的第一個HashEntry是否發(fā)生了改變”。
// 若是的話，則重置e，first和retries的值，并重新遍歷。
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
e = first = f; // re-traverse if entry changed
retries = -1;
}
}
return node;
}
說明：
scanAndLockForPut()的目標是獲取鎖。流程如下：
它首先會調用entryForHash()，根據hash值獲取”當前Segment中對應的HashEntry節(jié)點(first)，即找到對應的HashEntry鏈表“。
緊接著進入while循環(huán)。在while循環(huán)中，它會遍歷”HashEntry鏈表(e)“，查找”要插入的key-value鍵值對“在”該HashEntry鏈表上對應的節(jié)點“。
若找到的話，則不斷的自旋，即不斷的執(zhí)行while循環(huán)。在自旋期間，若通過tryLock()獲取鎖成功則返回；否則，在自旋MAX_SCAN_RETRIES次數之后，強制獲取鎖并退出。
若沒有找到的話，則新建一個HashEntry鏈表，然后不斷的自旋。在自旋期間，若通過tryLock()獲取鎖成功則返回；否則，在自旋MAX_SCAN_RETRIES次數之后，強制獲取鎖并退出。
此外，若在自旋期間，HashEntry鏈表的表頭發(fā)生變化；則重新進行查找和自旋工作！
理解scanAndLockForPut()時，務必要聯系”哈希表“的數據結構。一個Segment本身就是一個哈希表，Segment中包含了”HashEntry數組“對象，而每一個HashEntry對象本身是一個”單向鏈表“。
下面看看rehash()的實現代碼。
private void rehash(HashEntry<K,V> node) {
HashEntry<K,V>[] oldTable = table;
// ”Segment中原始的HashEntry數組的長度“
int oldCapacity = oldTable.length;
// ”Segment中新HashEntry數組的長度“
int newCapacity = oldCapacity << 1;
// 新的閾值
threshold = (int)(newCapacity * loadFactor);
// 新的HashEntry數組
HashEntry<K,V>[] newTable =
(HashEntry<K,V>[]) new HashEntry[newCapacity];
int sizeMask = newCapacity - 1;
// 遍歷”原始的HashEntry數組“，
// 將”原始的HashEntry數組“中的每個”HashEntry鏈表“的值，都復制到”新的HashEntry數組的HashEntry元素“中。
for (int i = 0; i < oldCapacity ; i++) {
// 獲取”原始的HashEntry數組“中的”第i個HashEntry鏈表“
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;
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;
// 將”原始的HashEntry數組“中的”HashEntry鏈表(e)“的值，都復制到”新的HashEntry數組的HashEntry“中。
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);
}
}
}
}
// 將新的node節(jié)點添加到“Segment的新HashEntry數組(newTable)“中。
int nodeIndex = node.hash & sizeMask; // add the new node
node.setNext(newTable[nodeIndex]);
newTable[nodeIndex] = node;
table = newTable;
}
說明：rehash()的作用是將”Segment的容量“變?yōu)椤痹嫉腟egment容量的2倍“。
在將原始的數據拷貝到“新的Segment”中后，會將新增加的key-value鍵值對添加到“新的Segment”中。
setEntryAt()的源碼如下：
static final <K,V> void setEntryAt(HashEntry<K,V>[] tab, int i,
HashEntry<K,V> e) {
UNSAFE.putOrderedObject(tab, ((long)i << TSHIFT) + TBASE, e);
}
UNSAFE是Segment類中定義的“靜態(tài)sun.misc.Unsafe”對象。源碼如下：
static final sun.misc.Unsafe UNSAFE;
Unsafe.java在openjdk6中的路徑是：openjdk6/jdk/src/share/classes/sun/misc/Unsafe.java。其中，putOrderedObject()的源碼下：
public native void putOrderedObject(Object o, long offset, Object x);
說明：putOrderedObject()是一個本地方法。
它會設置obj對象中offset偏移地址對應的object型field的值為指定值。它是一個有序或者有延遲的putObjectVolatile()方法，并且不保證值的改變被其他線程立即看到。只有在field被volatile修飾并且期望被意外修改的時候，使用putOrderedObject()才有用。
總之，setEntryAt()的目的是設置tab中第i位置元素的值為e，且該設置會有延遲。
4 刪除
下面以remove(Object key)來對ConcurrentHashMap中的刪除操作來進行說明。
public V remove(Object key) {
int hash = hash(key);
// 根據hash值，找到key對應的Segment片段。
Segment<K,V> s = segmentForHash(hash);
return s == null ? null : s.remove(key, hash, null);
}
說明：remove()首先根據“key的計算出來的哈希值”找到對應的Segment片段，然后再從該Segment片段中刪除對應的“key-value鍵值對”。
remove()的方法如下：
final V remove(Object key, int hash, Object value) {
// 嘗試獲取Segment對應的鎖。
// 嘗試失敗的話，則通過scanAndLock()來獲取鎖。
if (!tryLock())
scanAndLock(key, hash);
V oldValue = null;
try {
// 根據“hash值”找到“Segment的HashEntry數組”中對應的“HashEntry節(jié)點(e)”，該HashEntry節(jié)點是一HashEntry個鏈表。
HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash;
HashEntry<K,V> e = entryAt(tab, index);
HashEntry<K,V> pred = null;
// 遍歷“HashEntry鏈表”，刪除key-value鍵值對
while (e != null) {
K k;
HashEntry<K,V> next = e.next;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
V v = e.value;
if (value == null || value == v || value.equals(v)) {
if (pred == null)
setEntryAt(tab, index, next);
else
pred.setNext(next);
++modCount;
--count;
oldValue = v;
}
break;
}
pred = e;
e = next;
}
} finally {
// 釋放鎖
unlock();
}
return oldValue;
}
說明：remove()的目的就是刪除key-value鍵值對。在刪除之前，它會獲取到Segment的互斥鎖，在刪除之后，再釋放鎖。
它的刪除過程也比較簡單，它會先根據hash值，找到“Segment的HashEntry數組”中對應的“HashEntry”節(jié)點。根據Segment的數據結構，我們知道Segment中包含一個HashEntry數組對象，而每一個HashEntry本質上是一個單向鏈表。 在找到“HashEntry”節(jié)點之后，就遍歷該“HashEntry”節(jié)點對應的鏈表，找到key-value鍵值對對應的節(jié)點，然后刪除。
下面對scanAndLock()進行說明。它的源碼如下：
private void scanAndLock(Object key, int hash) {
// 第一個HashEntry節(jié)點
HashEntry<K,V> first = entryForHash(this, hash);
HashEntry<K,V> e = first;
int retries = -1;
// 查找”key-value鍵值對“在”HashEntry鏈表上對應的節(jié)點“；
// 無論找沒找到，最后都會不斷的自旋；在自旋期間，若通過tryLock()獲取鎖成功則返回；否則自旋MAX_SCAN_RETRIES次數之后，強制獲取”鎖“并退出。
// 若在自旋期間，HashEntry鏈表的表頭發(fā)生變化；則重新進行查找和自旋！
while (!tryLock()) {
HashEntry<K,V> f;
if (retries < 0) {
// 如果“遍歷完該HashEntry鏈表，仍然沒找到”要刪除的鍵值對“對應的節(jié)點”
// 或者“在該HashEntry鏈表上找到”要刪除的鍵值對“對應的節(jié)點”，則設置retries=0
// 否則，設置e為下一個HashEntry節(jié)點。
if (e == null || key.equals(e.key))
retries = 0;
else
e = e.next;
}
// 自旋超過限制次數之后，獲取鎖并退出。
else if (++retries > MAX_SCAN_RETRIES) {
lock();
break;
}
// 當“嘗試了偶數次”時，就獲取“當前Segment的第一個HashEntry”，即f。
// 然后，通過f!=first來判斷“當前Segment的第一個HashEntry是否發(fā)生了改變”。
// 若是的話，則重置e，first和retries的值，并重新遍歷。
else if ((retries & 1) == 0 &&
(f = entryForHash(this, hash)) != first) {
e = first = f;
retries = -1;
}
}
}
說明：scanAndLock()的目標是獲取鎖。它的實現與scanAndLockForPut()類似，這里就不再過多說明。
總結：ConcurrentHashMap是線程安全的哈希表，它是通過“鎖分段”來實現的。ConcurrentHashMap中包括了“Segment(鎖分段)數組”，每個Segment就是一個哈希表，而且也是可重入的互斥鎖。第一，Segment是哈希表表現在，Segment包含了“HashEntry數組”，而“HashEntry數組”中的每一個HashEntry元素是一個單向鏈表。即Segment是通過鏈式哈希表。第二，Segment是可重入的互斥鎖表現在，Segment繼承于ReentrantLock，而ReentrantLock就是可重入的互斥鎖。
對于ConcurrentHashMap的添加，刪除操作，在操作開始前，線程都會獲取Segment的互斥鎖；操作完畢之后，才會釋放。而對于讀取操作，它是通過volatile去實現的，HashEntry數組是volatile類型的，而volatile能保證“即對一個volatile變量的讀，總是能看到（任意線程）對這個volatile變量最后的寫入”，即我們總能讀到其它線程寫入HashEntry之后的值。 以上這些方式，就是ConcurrentHashMap線程安全的實現原理。
ConcurrentHashMap示例
下面，我們通過一個例子去對比HashMap和ConcurrentHashMap。
import java.util.*;
import java.util.concurrent.*;
/*
* ConcurrentHashMap是“線程安全”的哈希表，而HashMap是非線程安全的。
*
* 下面是“多個線程同時操作并且遍歷map”的示例
* () 當map是ConcurrentHashMap對象時，程序能正常運行。
* (02) 當map是HashMap對象時，程序會產生ConcurrentModificationException異常。
*
*
*/
public class ConcurrentHashMapDemo1 {
// TODO: map是HashMap對象時，程序會出錯。
//private static Map<String, String> map = new HashMap<String, String>();
private static Map<String, String> map = new ConcurrentHashMap<String, String>();
public static void main(String[] args) {
// 同時啟動兩個線程對map進行操作！
new MyThread("ta").start();
new MyThread("tb").start();
}
private static void printAll() {
String key, value;
Iterator iter = map.entrySet().iterator();
while(iter.hasNext()) {
Map.Entry entry = (Map.Entry)iter.next();
key = (String)entry.getKey();
value = (String)entry.getValue();
System.out.print(key+" - "+value+", ");
}
System.out.println();
}
private static class MyThread extends Thread {
MyThread(String name) {
super(name);
}
@Override
public void run() {
int i = 0;
while (i++ < 6) {
// “線程名” + "-" + "序號"
String val = Thread.currentThread().getName()+i;
map.put(String.valueOf(i), val);
// 通過“Iterator”遍歷map。
printAll();
}
}
}
}
(某一次)運行結果：
1 - tb1, 1 - tb1, 1 - tb1, 1 - tb1, 2 - tb2, 2 - tb2, 1 - tb1, 3 - ta3, 1 - tb1, 2 - tb2, 3 - tb3, 1 - tb1, 2 - tb2, 3 - tb3, 1 - tb1, 4 - tb4, 3 - tb3, 2 - tb2, 4 - tb4, 1 - tb1, 2 - tb2, 5 - ta5, 1 - tb1, 3 - tb3, 5 - tb5, 4 - tb4, 3 - tb3, 2 - tb2, 4 - tb4, 1 - tb1, 2 - tb2, 5 - tb5, 1 - tb1, 6 - tb6, 5 - tb5, 3 - tb3, 6 - tb6, 4 - tb4, 3 - tb3, 2 - tb2, 4 - tb4, 2 - tb2,
結果說明：如果將源碼中的map改成HashMap對象時，程序會產生ConcurrentModificationException異常。
以上所述是小編給大家介紹的Java concurrency集合之ConcurrentHashMap，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對腳本之家網站的支持！
相關文章
這篇文章主要介紹了spring webflux自定義netty 參數解析，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-09-09
這篇文章主要介紹了Java中基于maven實現zxing二維碼功能,非常不錯，具有參考借鑒價值，需要的朋友可以參考下2017-02-02
Spring Data Envers支持有條件變動紀錄的保存和查詢的方法
通過spring-data-envers可以很容易的實現數據變動紀錄的保存和查詢,本文介紹支持有條件變動紀錄的保存和查詢的方法,通過spring-data-envers很容易的實現變動紀錄的保存和查詢,只需要增加幾個注解就可以,感興趣的朋友跟隨小編一起看看吧2023-10-10
詳解Idea 2019.2 安裝lombok插件失效問題解決
這篇文章主要介紹了詳解Idea 2019.2 安裝lombok插件失效問題解決，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2019-10-10
這篇文章主要介紹了Springboot中的異步、定時、郵件任務，本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友參考下吧2021-11-11
今天想把一個用使用了HttpClient的自動簽到小程序移植到Android上，還好Android的SDK自帶了HttpClient的包.當然也可以繼續(xù)使用DefaultHttpClient，但用為Android定制的AndroidHttpClient自然更好2012-11-11
這篇文章主要給大家分享介紹了Java判空的一些常見方法,在程序中必須進行嚴格的判空處理,避免對空對象的異常操作,文中通過實例代碼介紹的非常詳細,需要的朋友可以參考下2023-07-07
這篇文章主要介紹了spring cloud openfeign 源碼實例解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-10-10
這篇文章主要介紹了Java訪問控制符原理及具體用法解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2020-11-11
Java實現前端jsencrypt.js加密后端解密的示例代碼
這篇文章主要為大家詳細介紹了如何利用jsencrypt.js實現前端加密，利用Java實現后端解密的功能，文中的示例代碼講解詳細，需要的可以參考一下2022-09-09