Java concurrency集合之ConcurrentHashMap_動(dòng)力節(jié)點(diǎn)Java學(xué)院整理

更新時(shí)間：2017年06月09日 15:20:01 投稿：mrr

這篇文章主要介紹了Java concurrency集合之ConcurrentHashMap的相關(guān)資料,需要的朋友可以參考下

ConcurrentHashMap介紹

ConcurrentHashMap是線程安全的哈希表。HashMap, Hashtable, ConcurrentHashMap之間的關(guān)聯(lián)如下：

　　HashMap是非線程安全的哈希表，常用于單線程程序中。

　　Hashtable是線程安全的哈希表，它是通過(guò)synchronized來(lái)保證線程安全的；即，多線程通過(guò)同一個(gè)“對(duì)象的同步鎖”來(lái)實(shí)現(xiàn)并發(fā)控制。Hashtable在線程競(jìng)爭(zhēng)激烈時(shí)，效率比較低(此時(shí)建議使用ConcurrentHashMap)！因?yàn)楫?dāng)一個(gè)線程訪問(wèn)Hashtable的同步方法時(shí)，其它線程就訪問(wèn)Hashtable的同步方法時(shí)，可能會(huì)進(jìn)入阻塞狀態(tài)。

　　ConcurrentHashMap是線程安全的哈希表，它是通過(guò)“鎖分段”來(lái)保證線程安全的。ConcurrentHashMap將哈希表分成許多片段(Segment)，每一個(gè)片段除了保存哈希表之外，本質(zhì)上也是一個(gè)“可重入的互斥鎖”(ReentrantLock)。多線程對(duì)同一個(gè)片段的訪問(wèn)，是互斥的；但是，對(duì)于不同片段的訪問(wèn)，卻是可以同步進(jìn)行的。

ConcurrentHashMap原理和數(shù)據(jù)結(jié)構(gòu)

要想搞清ConcurrentHashMap，必須先弄清楚它的數(shù)據(jù)結(jié)構(gòu)：

(01) ConcurrentHashMap繼承于AbstractMap抽象類(lèi)。

(02) Segment是ConcurrentHashMap中的內(nèi)部類(lèi)，它就是ConcurrentHashMap中的“鎖分段”對(duì)應(yīng)的存儲(chǔ)結(jié)構(gòu)。

ConcurrentHashMap與Segment是組合關(guān)系，1個(gè)ConcurrentHashMap對(duì)象包含若干個(gè)Segment對(duì)象。在代碼中，這表現(xiàn)為ConcurrentHashMap類(lèi)中存在“Segment數(shù)組”成員。

(03) Segment類(lèi)繼承于ReentrantLock類(lèi)，所以Segment本質(zhì)上是一個(gè)可重入的互斥鎖。

(04) HashEntry也是ConcurrentHashMap的內(nèi)部類(lèi)，是單向鏈表節(jié)點(diǎn)，存儲(chǔ)著key-value鍵值對(duì)。Segment與HashEntry是組合關(guān)系，Segment類(lèi)中存在“HashEntry數(shù)組”成員，“HashEntry數(shù)組”中的每個(gè)HashEntry就是一個(gè)單向鏈表。

對(duì)于多線程訪問(wèn)對(duì)一個(gè)“哈希表對(duì)象”競(jìng)爭(zhēng)資源，Hashtable是通過(guò)一把鎖來(lái)控制并發(fā)；而ConcurrentHashMap則是將哈希表分成許多片段，對(duì)于每一個(gè)片段分別通過(guò)一個(gè)互斥鎖來(lái)控制并發(fā)。ConcurrentHashMap對(duì)并發(fā)的控制更加細(xì)膩，它也更加適應(yīng)于高并發(fā)場(chǎng)景！

ConcurrentHashMap函數(shù)列表

// 創(chuàng)建一個(gè)帶有默認(rèn)初始容量 (16)、加載因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。
ConcurrentHashMap()
// 創(chuàng)建一個(gè)帶有指定初始容量、默認(rèn)加載因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。
ConcurrentHashMap(int initialCapacity)
// 創(chuàng)建一個(gè)帶有指定初始容量、加載因子和默認(rèn) concurrencyLevel (16) 的新的空映射。
ConcurrentHashMap(int initialCapacity, float loadFactor)
// 創(chuàng)建一個(gè)帶有指定初始容量、加載因子和并發(fā)級(jí)別的新的空映射。
ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)
// 構(gòu)造一個(gè)與給定映射具有相同映射關(guān)系的新映射。
ConcurrentHashMap(Map<? extends K,? extends V> m)
// 從該映射中移除所有映射關(guān)系
void clear()
// 一種遺留方法，測(cè)試此表中是否有一些與指定值存在映射關(guān)系的鍵。
boolean contains(Object value)
// 測(cè)試指定對(duì)象是否為此表中的鍵。
boolean containsKey(Object key)
// 如果此映射將一個(gè)或多個(gè)鍵映射到指定值，則返回 true。
boolean containsValue(Object value)
// 返回此表中值的枚舉。
Enumeration<V> elements()
// 返回此映射所包含的映射關(guān)系的 Set 視圖。
Set<Map.Entry<K,V>> entrySet()
// 返回指定鍵所映射到的值，如果此映射不包含該鍵的映射關(guān)系，則返回 null。
V get(Object key)
// 如果此映射不包含鍵-值映射關(guān)系，則返回 true。
boolean isEmpty()
// 返回此表中鍵的枚舉。
Enumeration<K> keys()
// 返回此映射中包含的鍵的 Set 視圖。
Set<K> keySet()
// 將指定鍵映射到此表中的指定值。
V put(K key, V value)
// 將指定映射中所有映射關(guān)系復(fù)制到此映射中。
void putAll(Map<? extends K,? extends V> m)
// 如果指定鍵已經(jīng)不再與某個(gè)值相關(guān)聯(lián)，則將它與給定值關(guān)聯(lián)。
V putIfAbsent(K key, V value)
// 從此映射中移除鍵（及其相應(yīng)的值）。
V remove(Object key)
// 只有目前將鍵的條目映射到給定值時(shí)，才移除該鍵的條目。
boolean remove(Object key, Object value)
// 只有目前將鍵的條目映射到某一值時(shí)，才替換該鍵的條目。
V replace(K key, V value)
// 只有目前將鍵的條目映射到給定值時(shí)，才替換該鍵的條目。
boolean replace(K key, V oldValue, V newValue)
// 返回此映射中的鍵-值映射關(guān)系數(shù)。
int size()
// 返回此映射中包含的值的 Collection 視圖。
Collection<V> values()

下面從ConcurrentHashMap的創(chuàng)建，獲取，添加，刪除這4個(gè)方面對(duì)ConcurrentHashMap進(jìn)行分析。

1 創(chuàng)建

下面以ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel)來(lái)進(jìn)行說(shuō)明。

@SuppressWarnings("unchecked")
public ConcurrentHashMap(int initialCapacity,
       float loadFactor, int concurrencyLevel) {
 // 參數(shù)有效性判斷
 if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
  throw new IllegalArgumentException();
 // concurrencyLevel是“用來(lái)計(jì)算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;
 // 哈希表的初始容量
 // 哈希表的實(shí)際容量=“segments的容量” x “segments中數(shù)組的長(zhǎng)度”
 if (initialCapacity > MAXIMUM_CAPACITY)
  initialCapacity = MAXIMUM_CAPACITY;
 // “哈希表的初始容量” / “segments的容量”
 int c = initialCapacity / ssize;
 if (c * ssize < initialCapacity)
  ++c;
 // cap就是“segments中的HashEntry數(shù)組的長(zhǎng)度”
 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;
}

說(shuō)明：

(01) 前面我們說(shuō)過(guò)，ConcurrentHashMap采用了“鎖分段”技術(shù)；在代碼中，它通過(guò)“segments數(shù)組”對(duì)象來(lái)保存各個(gè)分段。segments的定義如下：

final Segment<K,V>[] segments;

concurrencyLevel的作用就是用來(lái)計(jì)算segments數(shù)組的容量大小。先計(jì)算出“大于或等于concurrencyLevel的最小的2的N次方值”，然后將其保存為“segments的容量大小(ssize)”。

(02) initialCapacity是哈希表的初始容量。需要注意的是，哈希表的實(shí)際容量=“segments的容量” x “segments中數(shù)組的長(zhǎng)度”。

(03) loadFactor是加載因子。它是哈希表在其容量自動(dòng)增加之前可以達(dá)到多滿的一種尺度。

ConcurrentHashMap的構(gòu)造函數(shù)中涉及到的非常重要的一個(gè)結(jié)構(gòu)體，它就是Segment。下面看看Segment的聲明：

static final class Segment<K,V> extends ReentrantLock implements Serializable {
 ...
 transient volatile HashEntry<K,V>[] table;
 // threshold閾，是哈希表在其容量自動(dòng)增加之前可以達(dá)到多滿的一種尺度。
 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;
 }
 ...
}

說(shuō)明：Segment包含HashEntry數(shù)組，HashEntry保存了哈希表中的鍵值對(duì)。

此外，還需要說(shuō)明的Segment繼承于ReentrantLock。這意味著，Segment本質(zhì)上就是可重入的互斥鎖。

HashEntry的源碼如下：

static final class HashEntry<K,V> {
 final int hash; // 哈希值
 final K key;  // 鍵
 volatile V value; // 值
 volatile HashEntry<K,V> next; // 下一個(gè)HashEntry節(jié)點(diǎn)
 HashEntry(int hash, K key, V value, HashEntry<K,V> next) {
  this.hash = hash;
  this.key = key;
  this.value = value;
  this.next = next;
 }
 ..
}

說(shuō)明：和HashMap的節(jié)點(diǎn)一樣，HashEntry也是鏈表。這就說(shuō)明，ConcurrentHashMap是鏈?zhǔn)焦１?，它是通過(guò)“拉鏈法”來(lái)解決哈希沖突的。

2 獲取

下面以get(Object key)為例，對(duì)ConcurrentHashMap的獲取方法進(jìn)行說(shuō)明。

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對(duì)應(yīng)的Segment片段。
 // 如果Segment片段不為null，則在“Segment片段的HashEntry數(shù)組中”中找到key所對(duì)應(yīng)的HashEntry列表；
 // 接著遍歷該HashEntry鏈表，找到于key-value鍵值對(duì)對(duì)應(yīng)的HashEntry節(jié)點(diǎn)。
 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;
}

說(shuō)明：get(Object key)的作用是返回key在ConcurrentHashMap哈希表中對(duì)應(yīng)的值。

它首先根據(jù)key計(jì)算出來(lái)的哈希值，獲取key所對(duì)應(yīng)的Segment片段。

如果Segment片段不為null，則在“Segment片段的HashEntry數(shù)組中”中找到key所對(duì)應(yīng)的HashEntry列表。Segment包含“HashEntry數(shù)組”對(duì)象，而每一個(gè)HashEntry本質(zhì)上是一個(gè)單向鏈表。

接著遍歷該HashEntry鏈表，找到于key-value鍵值對(duì)對(duì)應(yīng)的HashEntry節(jié)點(diǎn)。

下面是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)來(lái)對(duì)ConcurrentHashMap中增加鍵值對(duì)來(lái)進(jìn)行說(shuō)明。

public V put(K key, V value) {
 Segment<K,V> s;
 if (value == null)
  throw new NullPointerException();
 // 獲取key對(duì)應(yīng)的哈希值
 int hash = hash(key);
 int j = (hash >>> segmentShift) & segmentMask;
 // 如果找不到該Segment，則新建一個(gè)。
 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);
}

說(shuō)明：

(01) put()根據(jù)key獲取對(duì)應(yīng)的哈希值，再根據(jù)哈希值找到對(duì)應(yīng)的Segment片段。如果Segment片段不存在，則新增一個(gè)Segment。

(02) 將key-value鍵值對(duì)添加到Segment片段中。

final V put(K key, int hash, V value, boolean onlyIfAbsent) {
 // tryLock()獲取鎖，成功返回true，失敗返回false。
 // 獲取鎖失敗的話，則通過(guò)scanAndLockForPut()獲取鎖，并返回”要插入的key-value“對(duì)應(yīng)的”HashEntry鏈表“。
 HashEntry<K,V> node = tryLock() ? null :
  scanAndLockForPut(key, hash, value);
 V oldValue;
 try {
  // tab代表”當(dāng)前Segment中的HashEntry數(shù)組“
  HashEntry<K,V>[] tab = table;
  // 根據(jù)”hash值“獲取”HashEntry數(shù)組中對(duì)應(yīng)的HashEntry鏈表“
  int index = (tab.length - 1) & hash;
  HashEntry<K,V> first = entryAt(tab, index);
  for (HashEntry<K,V> e = first;;) {
   // 如果”HashEntry鏈表中的當(dāng)前HashEntry節(jié)點(diǎn)“不為null，
   if (e != null) {
    K k;
    // 當(dāng)”要插入的key-value鍵值對(duì)“已經(jīng)存在于”HashEntry鏈表中“時(shí)，先保存原有的值。
    // 若”onlyIfAbsent“為true，即”要插入的key不存在時(shí)才插入”，則直接退出；
    // 否則，用新的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設(shè)置為“node的下一個(gè)節(jié)點(diǎn)”。
    // 否則，新建HashEntry鏈表
    if (node != null)
     node.setNext(first);
    else
     node = new HashEntry<K,V>(hash, key, value, first);
    int c = count + 1;
    // 如果添加key-value鍵值對(duì)之后，Segment中的元素超過(guò)閾值(并且，HashEntry數(shù)組的長(zhǎng)度沒(méi)超過(guò)限制)，則rehash；
    // 否則，直接添加key-value鍵值對(duì)。
    if (c > threshold && tab.length < MAXIMUM_CAPACITY)
     rehash(node);
    else
     setEntryAt(tab, index, node);
    ++modCount;
    count = c;
    oldValue = null;
    break;
   }
  }
 } finally {
  // 釋放鎖
  unlock();
 }
 return oldValue;
}

說(shuō)明：

put()的作用是將key-value鍵值對(duì)插入到“當(dāng)前Segment對(duì)應(yīng)的HashEntry中”，在插入前它會(huì)獲取Segment對(duì)應(yīng)的互斥鎖，插入后會(huì)釋放鎖。具體的插入過(guò)程如下：

(01) 首先根據(jù)“hash值”獲取“當(dāng)前Segment的HashEntry數(shù)組對(duì)象”中的“HashEntry節(jié)點(diǎn)”，每個(gè)HashEntry節(jié)點(diǎn)都是一個(gè)單向鏈表。

(02) 接著，遍歷HashEntry鏈表。

若在遍歷HashEntry鏈表時(shí)，找到與“要key-value鍵值對(duì)”對(duì)應(yīng)的節(jié)點(diǎn)，即“要插入的key-value鍵值對(duì)”的key已經(jīng)存在于HashEntry鏈表中。則根據(jù)onlyIfAbsent進(jìn)行判斷，若onlyIfAbsent為true，即“當(dāng)要插入的key不存在時(shí)才插入”，則不進(jìn)行插入，直接返回；否則，用新的value值覆蓋原始的value值，然后再返回。

若在遍歷HashEntry鏈表時(shí)，沒(méi)有找到與“要key-value鍵值對(duì)”對(duì)應(yīng)的節(jié)點(diǎn)。當(dāng)node!=null時(shí)，即在scanAndLockForPut()獲取鎖時(shí)，已經(jīng)新建了key-value對(duì)應(yīng)的HashEntry節(jié)點(diǎn)，則”將HashEntry添加到Segment中“；否則，新建key-value對(duì)應(yīng)的HashEntry節(jié)點(diǎn)，然后再“將HashEntry添加到Segment中”。在”將HashEntry添加到Segment中“前，會(huì)判斷是否需要rehash。如果在添加key-value鍵值之后，容量會(huì)超過(guò)閾值，并且HashEntry數(shù)組的長(zhǎng)度沒(méi)有超過(guò)限制，則進(jìn)行rehash；否則，直接通過(guò)setEntryAt()將key-value鍵值對(duì)添加到Segment中。

在介紹rehash()和setEntryAt()之前，我們先看看自旋函數(shù)scanAndLockForPut()。下面是它的源碼：

private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
 // 第一個(gè)HashEntry節(jié)點(diǎn)
 HashEntry<K,V> first = entryForHash(this, hash);
 // 當(dāng)前的HashEntry節(jié)點(diǎn)
 HashEntry<K,V> e = first;
 HashEntry<K,V> node = null;
 // 重復(fù)計(jì)數(shù)(自旋計(jì)數(shù)器)
 int retries = -1; // negative while locating node
 // 查找”key-value鍵值對(duì)“在”HashEntry鏈表上對(duì)應(yīng)的節(jié)點(diǎn)“；
 // 若找到的話，則不斷的自旋；在自旋期間，若通過(guò)tryLock()獲取鎖成功則返回；否則自旋MAX_SCAN_RETRIES次數(shù)之后，強(qiáng)制獲取”鎖“并退出。
 // 若沒(méi)有找到的話，則新建一個(gè)HashEntry鏈表。然后不斷的自旋。
 // 此外，若在自旋期間，HashEntry鏈表的表頭發(fā)生變化；則重新進(jìn)行查找和自旋工作！
 while (!tryLock()) {
  HashEntry<K,V> f; // to recheck first below
  // 1. retries<0的處理情況
  if (retries < 0) {
   // 1.1 如果當(dāng)前的HashEntry節(jié)點(diǎn)為空(意味著，在該HashEntry鏈表上上沒(méi)有找到”要插入的鍵值對(duì)“對(duì)應(yīng)的節(jié)點(diǎn))，而且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 如果當(dāng)前的HashEntry節(jié)點(diǎn)是”要插入的鍵值對(duì)在該HashEntry上對(duì)應(yīng)的節(jié)點(diǎn)“，則設(shè)置retries=0
   else if (key.equals(e.key))
    retries = 0;
   // 1.3 設(shè)置為下一個(gè)HashEntry。
   else
    e = e.next;
  }
  // 2. 如果自旋次數(shù)超過(guò)限制，則獲取“鎖”并退出
  else if (++retries > MAX_SCAN_RETRIES) {
   lock();
   break;
  }
  // 3. 當(dāng)“嘗試了偶數(shù)次”時(shí)，就獲取“當(dāng)前Segment的第一個(gè)HashEntry”，即f。
  // 然后，通過(guò)f!=first來(lái)判斷“當(dāng)前Segment的第一個(gè)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;
}

說(shuō)明：

scanAndLockForPut()的目標(biāo)是獲取鎖。流程如下：

它首先會(huì)調(diào)用entryForHash()，根據(jù)hash值獲取”當(dāng)前Segment中對(duì)應(yīng)的HashEntry節(jié)點(diǎn)(first)，即找到對(duì)應(yīng)的HashEntry鏈表“。

緊接著進(jìn)入while循環(huán)。在while循環(huán)中，它會(huì)遍歷”HashEntry鏈表(e)“，查找”要插入的key-value鍵值對(duì)“在”該HashEntry鏈表上對(duì)應(yīng)的節(jié)點(diǎn)“。

若找到的話，則不斷的自旋，即不斷的執(zhí)行while循環(huán)。在自旋期間，若通過(guò)tryLock()獲取鎖成功則返回；否則，在自旋MAX_SCAN_RETRIES次數(shù)之后，強(qiáng)制獲取鎖并退出。

若沒(méi)有找到的話，則新建一個(gè)HashEntry鏈表，然后不斷的自旋。在自旋期間，若通過(guò)tryLock()獲取鎖成功則返回；否則，在自旋MAX_SCAN_RETRIES次數(shù)之后，強(qiáng)制獲取鎖并退出。

此外，若在自旋期間，HashEntry鏈表的表頭發(fā)生變化；則重新進(jìn)行查找和自旋工作！

理解scanAndLockForPut()時(shí)，務(wù)必要聯(lián)系”哈希表“的數(shù)據(jù)結(jié)構(gòu)。一個(gè)Segment本身就是一個(gè)哈希表，Segment中包含了”HashEntry數(shù)組“對(duì)象，而每一個(gè)HashEntry對(duì)象本身是一個(gè)”單向鏈表“。

下面看看rehash()的實(shí)現(xiàn)代碼。

private void rehash(HashEntry<K,V> node) {
 HashEntry<K,V>[] oldTable = table;
 // ”Segment中原始的HashEntry數(shù)組的長(zhǎng)度“
 int oldCapacity = oldTable.length;
 // ”Segment中新HashEntry數(shù)組的長(zhǎng)度“
 int newCapacity = oldCapacity << 1;
 // 新的閾值
 threshold = (int)(newCapacity * loadFactor);
 // 新的HashEntry數(shù)組
 HashEntry<K,V>[] newTable =
  (HashEntry<K,V>[]) new HashEntry[newCapacity];
 int sizeMask = newCapacity - 1;
 // 遍歷”原始的HashEntry數(shù)組“，
 // 將”原始的HashEntry數(shù)組“中的每個(gè)”HashEntry鏈表“的值，都復(fù)制到”新的HashEntry數(shù)組的HashEntry元素“中。
 for (int i = 0; i < oldCapacity ; i++) {
  // 獲取”原始的HashEntry數(shù)組“中的”第i個(gè)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數(shù)組“中的”HashEntry鏈表(e)“的值，都復(fù)制到”新的HashEntry數(shù)組的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é)點(diǎn)添加到“Segment的新HashEntry數(shù)組(newTable)“中。
 int nodeIndex = node.hash & sizeMask; // add the new node
 node.setNext(newTable[nodeIndex]);
 newTable[nodeIndex] = node;
 table = newTable;
}

說(shuō)明：rehash()的作用是將”Segment的容量“變?yōu)椤痹嫉腟egment容量的2倍“。

在將原始的數(shù)據(jù)拷貝到“新的Segment”中后，會(huì)將新增加的key-value鍵值對(duì)添加到“新的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類(lèi)中定義的“靜態(tài)sun.misc.Unsafe”對(duì)象。源碼如下：

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);

說(shuō)明：putOrderedObject()是一個(gè)本地方法。

它會(huì)設(shè)置obj對(duì)象中offset偏移地址對(duì)應(yīng)的object型field的值為指定值。它是一個(gè)有序或者有延遲的putObjectVolatile()方法，并且不保證值的改變被其他線程立即看到。只有在field被volatile修飾并且期望被意外修改的時(shí)候，使用putOrderedObject()才有用。
總之，setEntryAt()的目的是設(shè)置tab中第i位置元素的值為e，且該設(shè)置會(huì)有延遲。

4 刪除

下面以remove(Object key)來(lái)對(duì)ConcurrentHashMap中的刪除操作來(lái)進(jìn)行說(shuō)明。

public V remove(Object key) {
 int hash = hash(key);
 // 根據(jù)hash值，找到key對(duì)應(yīng)的Segment片段。
 Segment<K,V> s = segmentForHash(hash);
 return s == null ? null : s.remove(key, hash, null);
}

說(shuō)明：remove()首先根據(jù)“key的計(jì)算出來(lái)的哈希值”找到對(duì)應(yīng)的Segment片段，然后再?gòu)脑揝egment片段中刪除對(duì)應(yīng)的“key-value鍵值對(duì)”。

remove()的方法如下：

final V remove(Object key, int hash, Object value) {
 // 嘗試獲取Segment對(duì)應(yīng)的鎖。
 // 嘗試失敗的話，則通過(guò)scanAndLock()來(lái)獲取鎖。
 if (!tryLock())
  scanAndLock(key, hash);
 V oldValue = null;
 try {
  // 根據(jù)“hash值”找到“Segment的HashEntry數(shù)組”中對(duì)應(yīng)的“HashEntry節(jié)點(diǎn)(e)”，該HashEntry節(jié)點(diǎn)是一HashEntry個(gè)鏈表。
  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鍵值對(duì)
  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;
}

說(shuō)明：remove()的目的就是刪除key-value鍵值對(duì)。在刪除之前，它會(huì)獲取到Segment的互斥鎖，在刪除之后，再釋放鎖。

它的刪除過(guò)程也比較簡(jiǎn)單，它會(huì)先根據(jù)hash值，找到“Segment的HashEntry數(shù)組”中對(duì)應(yīng)的“HashEntry”節(jié)點(diǎn)。根據(jù)Segment的數(shù)據(jù)結(jié)構(gòu)，我們知道Segment中包含一個(gè)HashEntry數(shù)組對(duì)象，而每一個(gè)HashEntry本質(zhì)上是一個(gè)單向鏈表。在找到“HashEntry”節(jié)點(diǎn)之后，就遍歷該“HashEntry”節(jié)點(diǎn)對(duì)應(yīng)的鏈表，找到key-value鍵值對(duì)對(duì)應(yīng)的節(jié)點(diǎn)，然后刪除。

下面對(duì)scanAndLock()進(jìn)行說(shuō)明。它的源碼如下：

private void scanAndLock(Object key, int hash) {
 // 第一個(gè)HashEntry節(jié)點(diǎn)
 HashEntry<K,V> first = entryForHash(this, hash);
 HashEntry<K,V> e = first;
 int retries = -1;

// 查找”key-value鍵值對(duì)“在”HashEntry鏈表上對(duì)應(yīng)的節(jié)點(diǎn)“；
 // 無(wú)論找沒(méi)找到，最后都會(huì)不斷的自旋；在自旋期間，若通過(guò)tryLock()獲取鎖成功則返回；否則自旋MAX_SCAN_RETRIES次數(shù)之后，強(qiáng)制獲取”鎖“并退出。
 // 若在自旋期間，HashEntry鏈表的表頭發(fā)生變化；則重新進(jìn)行查找和自旋！
 while (!tryLock()) {
  HashEntry<K,V> f;
  if (retries < 0) {
   // 如果“遍歷完該HashEntry鏈表，仍然沒(méi)找到”要?jiǎng)h除的鍵值對(duì)“對(duì)應(yīng)的節(jié)點(diǎn)”
   // 或者“在該HashEntry鏈表上找到”要?jiǎng)h除的鍵值對(duì)“對(duì)應(yīng)的節(jié)點(diǎn)”，則設(shè)置retries=0
   // 否則，設(shè)置e為下一個(gè)HashEntry節(jié)點(diǎn)。
   if (e == null || key.equals(e.key))
    retries = 0;
   else
    e = e.next;
  }
  // 自旋超過(guò)限制次數(shù)之后，獲取鎖并退出。
  else if (++retries > MAX_SCAN_RETRIES) {
   lock();
   break;
  }
  // 當(dāng)“嘗試了偶數(shù)次”時(shí)，就獲取“當(dāng)前Segment的第一個(gè)HashEntry”，即f。
  // 然后，通過(guò)f!=first來(lái)判斷“當(dāng)前Segment的第一個(gè)HashEntry是否發(fā)生了改變”。
  // 若是的話，則重置e，first和retries的值，并重新遍歷。
  else if ((retries & 1) == 0 &&
     (f = entryForHash(this, hash)) != first) {
   e = first = f;
   retries = -1;
  }
 }
}

說(shuō)明：scanAndLock()的目標(biāo)是獲取鎖。它的實(shí)現(xiàn)與scanAndLockForPut()類(lèi)似，這里就不再過(guò)多說(shuō)明。

總結(jié)：ConcurrentHashMap是線程安全的哈希表，它是通過(guò)“鎖分段”來(lái)實(shí)現(xiàn)的。ConcurrentHashMap中包括了“Segment(鎖分段)數(shù)組”，每個(gè)Segment就是一個(gè)哈希表，而且也是可重入的互斥鎖。第一，Segment是哈希表表現(xiàn)在，Segment包含了“HashEntry數(shù)組”，而“HashEntry數(shù)組”中的每一個(gè)HashEntry元素是一個(gè)單向鏈表。即Segment是通過(guò)鏈?zhǔn)焦１?。第二，Segment是可重入的互斥鎖表現(xiàn)在，Segment繼承于ReentrantLock，而ReentrantLock就是可重入的互斥鎖。

對(duì)于ConcurrentHashMap的添加，刪除操作，在操作開(kāi)始前，線程都會(huì)獲取Segment的互斥鎖；操作完畢之后，才會(huì)釋放。而對(duì)于讀取操作，它是通過(guò)volatile去實(shí)現(xiàn)的，HashEntry數(shù)組是volatile類(lèi)型的，而volatile能保證“即對(duì)一個(gè)volatile變量的讀，總是能看到（任意線程）對(duì)這個(gè)volatile變量最后的寫(xiě)入”，即我們總能讀到其它線程寫(xiě)入HashEntry之后的值。以上這些方式，就是ConcurrentHashMap線程安全的實(shí)現(xiàn)原理。

ConcurrentHashMap示例

下面，我們通過(guò)一個(gè)例子去對(duì)比HashMap和ConcurrentHashMap。

 import java.util.*;
 import java.util.concurrent.*;
 /*
  *  ConcurrentHashMap是“線程安全”的哈希表，而HashMap是非線程安全的。
  *
  *  下面是“多個(gè)線程同時(shí)操作并且遍歷map”的示例
  *  () 當(dāng)map是ConcurrentHashMap對(duì)象時(shí)，程序能正常運(yùn)行。
  *  (02) 當(dāng)map是HashMap對(duì)象時(shí)，程序會(huì)產(chǎn)生ConcurrentModificationException異常。
 *
 *
 */
 public class ConcurrentHashMapDemo1 {
   // TODO: map是HashMap對(duì)象時(shí)，程序會(huì)出錯(cuò)。
   //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) {
     // 同時(shí)啟動(dòng)兩個(gè)線程對(duì)map進(jìn)行操作！
     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) {
         // “線程名” + "-" + "序號(hào)"
         String val = Thread.currentThread().getName()+i;
         map.put(String.valueOf(i), val);
         // 通過(guò)“Iterator”遍歷map。
         printAll();
       }
     }
   }
 }

(某一次)運(yùn)行結(jié)果：

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,

結(jié)果說(shuō)明：如果將源碼中的map改成HashMap對(duì)象時(shí)，程序會(huì)產(chǎn)生ConcurrentModificationException異常。

以上所述是小編給大家介紹的Java concurrency集合之ConcurrentHashMap，希望對(duì)大家有所幫助，如果大家有任何疑問(wèn)請(qǐng)給我留言，小編會(huì)及時(shí)回復(fù)大家的。在此也非常感謝大家對(duì)腳本之家網(wǎng)站的支持！

您可能感興趣的文章: