java.util.concurrent
類別 ConcurrentHashMap<K,V>

java.lang.Object
  java.util.AbstractMap<K,V>
      java.util.concurrent.ConcurrentHashMap<K,V>

型別參數：

K - 此映射維護的鍵的型別

V - 映射值的類別

所有已實作的介面：

Serializable, ConcurrentMap<K,V>, Map<K,V>

public class ConcurrentHashMap<K,V>
extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable

支持獲取的完全共時和更新的所期望可調整共時的雜湊表。此類別遵守與 Hashtable 相同的功能規範，並且包括對應於 Hashtable 的每個方法的方法版本。不過，儘管所有操作都是執行緒安全的，但獲取操作不 必鎖定，並且不 支持以某種防止所有存取的方式鎖定整個表。此類別可以通過程序完全與 Hashtable 進行互操作，這取決於其執行緒安全，而與其同步細節無關。

獲取操作（包括 get）通常不會受阻塞，因此，可能與更新操作交迭（包括 put 和 remove）。獲取會影響最近完成的 更新操作的結果。對於一些聚合操作，比如 putAll 和 clear，共時獲取可能只影響某些條目的插入和移除。類似地，在創建迭代器/列舉時或自此之後，Iterators 和 Enumerations 返回在某一時間點上影響雜湊表狀態的元素。它們不會 拋出 ConcurrentModificationException。不過，迭代器被設計成每次僅由一個執行緒使用。

這允許通過可選的 concurrencyLevel 建構子參數（預設值為 16）來引導更新操作之間的共時，該參數用作內部調整大小的一個提示。表是在內部進行分區的，試圖允許指示無爭用共時更新的數量。因為雜湊表中的位置基本上是隨意的，所以實際的共時將各不相同。理想情況下，應該選擇一個盡可能多地容納共時修改該表的執行緒的值。使用一個比所需要的值高很多的值可能會浪費空間和時間，而使用一個顯然低很多的值可能導致執行緒爭用。對數量級估計過高或估計過低通常都會帶來非常顯著的影響。當僅有一個執行緒將執行修改操作，而其他所有執行緒都只是執行讀取操作時，才認為某個值是合適的。此外，重新調整此類別或其他任何種類別雜湊表的大小都是一個相對較慢的操作，因此，在可能的時候，提供建構子中期望表大小的估計值是一個好主意。

此類別及其視圖和迭代器實作了 Map 和 Iterator 介面的所有可選 方法。

此類別與 Hashtable 相似，但與 HashMap 不同，它不 允許將 null 用作鍵或值。

此類別是 Java Collections Framework 的成員。

從以下版本開始：

1.5

另請參見：

序列化表格

巢狀類別摘要

從類別 java.util.AbstractMap 繼承的巢狀類別/介面

AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>

從介面 java.util.Map 繼承的巢狀類別/介面

Map.Entry<K,V>

建構子摘要

ConcurrentHashMap()
創建一個帶有預設初始容量 (16)、載入因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。

ConcurrentHashMap(int initialCapacity)
創建一個帶有指定初始容量、預設載入因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。

ConcurrentHashMap(int initialCapacity, float loadFactor)
創建一個帶有指定初始容量、載入因子和預設 concurrencyLevel (16) 的新的空映射。

ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)
創建一個帶有指定初始容量、載入因子和共時級別的新的空映射。

ConcurrentHashMap(Map<? extends K,? extends V> m)
建構一個與給定映射具有相同映射關係的新映射。

方法摘要

void	clear() 從該映射中移除所有映射關係
boolean	contains(Object value) 一種遺留方法，測試此表中是否有一些與指定值存在映射關係的鍵。
boolean	containsKey(Object key) 測試指定物件是否為此表中的鍵。
boolean	containsValue(Object value) 如果此映射將一個或多個鍵映射到指定值，則返回 true。
Enumeration<V>	elements() 返回此表中值的列舉。
Set<Map.Entry<K,V>>	entrySet() 返回此映射所包含的映射關係的 Set 視圖。
V	get(Object key) 返回指定鍵所映射到的值，如果此映射不包含該鍵的映射關係，則返回 null。
boolean	isEmpty() 如果此映射不包含鍵-值映射關係，則返回 true。
Enumeration<K>	keys() 返回此表中鍵的列舉。
Set<K>	keySet() 返回此映射中包含的鍵的 Set 視圖。
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<V>	values() 返回此映射中包含的值的 Collection 視圖。

從類別 java.util.AbstractMap 繼承的方法

clone, equals, hashCode, toString

從類別 java.lang.Object 繼承的方法

finalize, getClass, notify, notifyAll, wait, wait, wait

從介面 java.util.Map 繼承的方法

equals, hashCode

建構子詳細資訊

ConcurrentHashMap

public ConcurrentHashMap(int initialCapacity,
                         float loadFactor,
                         int concurrencyLevel)

創建一個帶有指定初始容量、載入因子和共時級別的新的空映射。

參數：

initialCapacity - 初始容量。該實作執行內部大小調整，以容納這些元素。

loadFactor - 載入因子閾值，用來控制重新調整大小。在每 bin 中的平均元素數大於此閾值時，可能要重新調整大小。

concurrencyLevel - 當前更新執行緒的估計數。該實作將執行內部大小調整，以盡量容納這些執行緒。

拋出：

IllegalArgumentException - 如果初始容量為負，或者載入因子或 concurrencyLevel 為非正。

ConcurrentHashMap

public ConcurrentHashMap(int initialCapacity,
                         float loadFactor)

創建一個帶有指定初始容量、載入因子和預設 concurrencyLevel (16) 的新的空映射。

參數：

initialCapacity - 該實作執行內部的大小調整，以容納這些元素。

loadFactor - 載入因子閾值，用來控制重新調整大小。在每 bin 中的平均元素數大於此閾值時，可能要重新調整大小。

拋出：

IllegalArgumentException - 如果元素的初始容量為負，或者載入因子為非正

從以下版本開始：

1.6

ConcurrentHashMap

public ConcurrentHashMap(int initialCapacity)

創建一個帶有指定初始容量、預設載入因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。

參數：

initialCapacity - 初始容量。該實作執行內部的大小調整，以容納這些元素。

拋出：

IllegalArgumentException - 如果元素的初始容量為負。

ConcurrentHashMap

public ConcurrentHashMap()

創建一個帶有預設初始容量 (16)、載入因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。

ConcurrentHashMap

public ConcurrentHashMap(Map<? extends K,? extends V> m)

建構一個與給定映射具有相同映射關係的新映射。使用給定映射中映射關係數 1.5 倍的容量或 16（選更大的那一個）、預設載入因子 (0.75) 和 concurrencyLevel (16) 來創建該映射。

參數：

m - 映射

方法詳細資訊

isEmpty

public boolean isEmpty()

如果此映射不包含鍵-值映射關係，則返回 true。

指定者：

介面 Map<K,V> 中的 isEmpty

覆寫：

類別 AbstractMap<K,V> 中的 isEmpty

返回：

如果此映射不包含鍵-值映射關係，則返回 true

size

public int size()

返回此映射中的鍵-值映射關係數。如果該映射包含的元素多於 Integer.MAX_VALUE，則返回 Integer.MAX_VALUE。

指定者：

介面 Map<K,V> 中的 size

覆寫：

類別 AbstractMap<K,V> 中的 size

返回：

此映射中的鍵-值映射關係數

get

public V get(Object key)

返回指定鍵所映射到的值，如果此映射不包含該鍵的映射關係，則返回 null。

更確切地講，如果此映射包含滿足從鍵 k 到值 v 的映射關係 key.equals(k)，則此方法返回 v；否則它返回 null。（最多只能有一個這樣的映射關係）。

指定者：

介面 Map<K,V> 中的 get

覆寫：

類別 AbstractMap<K,V> 中的 get

參數：

key - 要返回其關聯值的鍵

返回：

指定鍵所映射的值；如果此映射不包含該鍵的映射關係，則返回 null

拋出：

NullPointerException - 如果指定鍵為 null

containsKey

public boolean containsKey(Object key)

測試指定物件是否為此表中的鍵。

指定者：

介面 Map<K,V> 中的 containsKey

覆寫：

類別 AbstractMap<K,V> 中的 containsKey

參數：

key - 可能的鍵

返回：

當且僅當指定物件（由 equals 方法確定）是此表中的鍵時，返回 true；否則返回 false。

拋出：

NullPointerException - 如果指定鍵為 null

containsValue

public boolean containsValue(Object value)

如果此映射將一個或多個鍵映射到指定值，則返回 true。註：此方法需要完全內部遍歷雜湊表，因此它比方法 containsKey 更慢。

指定者：

介面 Map<K,V> 中的 containsValue

覆寫：

類別 AbstractMap<K,V> 中的 containsValue

參數：

value - 測試在此映射中是否存在的值

返回：

如果此映射將一個或多個鍵映射到指定值，則返回 true

拋出：

NullPointerException - 如果指定值為 null

contains

public boolean contains(Object value)

一種遺留方法，測試此表中是否有一些與指定值存在映射關係的鍵。此方法在功能上等同於 containsValue(java.lang.Object)，並且它的存在只是為了確保與 Hashtable 類別完全相容，在引入 Java Collection 框架之前，該類別支持此方法。

參數：

value - 要搜尋的值

返回：

當且僅當此表中某個鍵映射到 value 參數時（由 equals 方法確定），返回 true；否則返回 false

拋出：

NullPointerException - 如果指定值為 null

put

public V put(K key,
             V value)

將指定鍵映射到此表中的指定值。鍵和值都不可以為 null。

通過使用與原來的鍵相同的鍵調用 get 方法，可以獲取相應的值。

指定者：

介面 Map<K,V> 中的 put

覆寫：

類別 AbstractMap<K,V> 中的 put

參數：

key - 與指定值相關聯的鍵

value - 與指定鍵相關聯的值

返回：

以前與 key 相關聯的值，如果 key 沒有映射關係，則返回 null

拋出：

NullPointerException - 如果指定鍵或值為 null

putIfAbsent

public V putIfAbsent(K key,
                     V value)

如果指定鍵已經不再與某個值相關聯，則將它與給定值關聯。這等價於：

   if (!map.containsKey(key)) 
      return map.put(key, value);
  else
       return map.get(key);

除了原子地執行此操作之外。

指定者：

介面 ConcurrentMap<K,V> 中的 putIfAbsent

參數：

key - 與指定值相關聯的鍵

value - 與指定鍵相關聯的值

返回：

以前與指定鍵相關聯的值，如果該鍵沒有映射關係，則返回 null

拋出：

NullPointerException - 如果指定鍵或值為 null

putAll

public void putAll(Map<? extends K,? extends V> m)

將指定映射中所有映射關係複製到此映射中。針對指定映射中的當前所有鍵，這些映射關係將替換此映射中具有的所有映射關係。

指定者：

介面 Map<K,V> 中的 putAll

覆寫：

類別 AbstractMap<K,V> 中的 putAll

參數：

m - 將存儲在此映射中的映射關係

remove

public V remove(Object key)

從此映射中移除鍵（及其相應的值）。如果該鍵不在映射中，則此方法不執行任何操作。

指定者：

介面 Map<K,V> 中的 remove

覆寫：

類別 AbstractMap<K,V> 中的 remove

參數：

key - 需要移除的鍵

返回：

與 key 關聯的先前值；如果 key 沒有映射關係，則返回 null

拋出：

NullPointerException - 如果指定鍵為 null

remove

public boolean remove(Object key,
                      Object value)

只有目前將鍵的條目映射到給定值時，才移除該鍵的條目。這等效於：

   if (map.containsKey(key) && map.get(key).equals(value)) {
       map.remove(key);
       return true;
   } else return false;

不同之處在於該操作是以原子方式 (atomically) 執行的。

指定者：

介面 ConcurrentMap<K,V> 中的 remove

參數：

key - 與指定值相關聯的鍵

value - 期望與指定鍵相關聯的值

返回：

如果該值被移除，則返回 true

拋出：

NullPointerException - 如果指定鍵為 null

replace

public boolean replace(K key,
                       V oldValue,
                       V newValue)

只有目前將鍵的條目映射到給定值時，才替換該鍵的條目。這等效於：

   if (map.containsKey(key) && map.get(key).equals(oldValue)) {
       map.put(key, newValue);
       return true;
   } else return false;

不同之處在於該操作是以原子方式執行的。

指定者：

介面 ConcurrentMap<K,V> 中的 replace

參數：

key - 與指定值相關聯的鍵

oldValue - 期望與指定鍵相關聯的值

newValue - 與指定鍵相關聯的值

返回：

如果該值被替換，則返回 true

拋出：

NullPointerException - 如果任何參數為 null

replace

public V replace(K key,
                 V value)

只有目前將鍵的條目映射到某一值時，才替換該鍵的條目。這等效於：

   if (map.containsKey(key)) {
       return map.put(key, value);
   } else return null;

不同之處在於該操作是以原子方式執行的。

指定者：

介面 ConcurrentMap<K,V> 中的 replace

參數：

key - 與指定值相關聯的鍵

value - 與指定鍵相關聯的值

返回：

與指定鍵關聯的先前值；如果沒有該鍵的映射關係，則返回 null

拋出：

NullPointerException - 如果指定鍵或值為 null

clear

public void clear()

從該映射中移除所有映射關係

指定者：

介面 Map<K,V> 中的 clear

覆寫：

類別 AbstractMap<K,V> 中的 clear

keySet

public Set<K> keySet()

返回此映射中包含的鍵的 Set 視圖。該 set 受映射支持，所以對映射的改變可在該 set 中反映出來，反之亦然。該 set 支持元素的移除，它通過 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作，從此映射中移除相應的映射關係。它不支持 add 或 addAll 操作。

該視圖的 iterator 是一個“弱一致”的迭代器，它從來不會拋出 ConcurrentModificationException，並且確保可遍歷迭代器建構時存在的元素，此外還可能（但並不保證）反映建構後的所有修改。

指定者：

介面 Map<K,V> 中的 keySet

覆寫：

類別 AbstractMap<K,V> 中的 keySet

返回：

此映射中包含的鍵的 set 視圖

values

public Collection<V> values()

返回此映射中包含的值的 Collection 視圖。該 collection 受映射支持，所以對映射的改變可在該 collection 中反映出來，反之亦然。該 collection 支持元素的移除，它通過 Iterator.remove、Collection.remove、removeAll、retainAll 和 clear 操作，從此映射中移除相應的映射關係。它不支持 add 或 addAll 操作。

該視圖的 iterator 是一個“弱一致”迭代器，它不會拋出 ConcurrentModificationException，並且確保可遍歷迭代器建構時存在的元素，此外還可能（但並不保證）反映建構後的所有修改。

指定者：

介面 Map<K,V> 中的 values

覆寫：

類別 AbstractMap<K,V> 中的 values

返回：

此映射中包含的值的 collection 視圖

entrySet

public Set<Map.Entry<K,V>> entrySet()

返回此映射所包含的映射關係的 Set 視圖。該 set 受映射支持，所以對映射的改變可在該 set 中反映出來，反之亦然。該 set 支持元素的移除，它通過 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作，從此映射中移除相應的映射關係。它不支持 add 或 addAll 操作。

該視圖的返回的 iterator 是一個“弱一致”迭代器，它不會拋出 ConcurrentModificationException，並且確保可遍歷迭代器建構時存在的元素，此外還可能（但並不保證）反映建構後的所有修改。

指定者：

介面 Map<K,V> 中的 entrySet

指定者：

類別 AbstractMap<K,V> 中的 entrySet

返回：

此映射中包含的映射關係的 set 視圖

keys

public Enumeration<K> keys()

返回此表中鍵的列舉。

返回：

此表中鍵的列舉

另請參見：

keySet()

elements

public Enumeration<V> elements()

返回此表中值的列舉。

返回：

此表中值的列舉

另請參見：

values()