java.lang.Object
java.util.AbstractMap<K,V>
java.util.concurrent.ConcurrentHashMap<K,V>
K - the type of keys maintained by this map
V - the type of mapped values
public class ConcurrentHashMap<K,V>
A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updates. This class obeys the same functional specification as Hashtable, and includes versions of methods corresponding to each method of Hashtable. However, even though all operations are thread-safe, retrieval operations do not entail locking, and there is not any support for locking the entire table in a way that prevents all access. This class is fully interoperable with Hashtable in programs that rely on its thread safety but not on its synchronization details.
Retrieval operations (including get) generally do not block, so may overlap with update operations (including put and remove). Retrievals reflect the results of the most recently completed update operations holding upon their onset. For aggregate operations such as putAll and clear, concurrent retrievals may reflect insertion or removal of only some entries. Similarly, Iterators and Enumerations return elements reflecting the state of the hash table at some point at or since the creation of the iterator/enumeration. They do not throw ConcurrentModificationException. However, iterators are designed to be used by only one thread at a time.
The allowed concurrency among update operations is guided by the optional concurrencyLevel constructor argument (default 16), which is used as a hint for internal sizing. The table is internally partitioned to try to permit the indicated number of concurrent updates without contention. Because placement in hash tables is essentially random, the actual concurrency will vary. Ideally, you should choose a value to accommodate as many threads as will ever concurrently modify the table. Using a significantly higher value than you need can waste space and time, and a significantly lower value can lead to thread contention. But overestimates and underestimates within an order of magnitude do not usually have much noticeable impact. A value of one is appropriate when it is known that only one thread will modify and all others will only read. Also, resizing this or any other kind of hash table is a relatively slow operation, so, when possible, it is a good idea to provide estimates of expected table sizes in constructors.
This class and its views and iterators implement all of the optional methods of the Map and Iterator interfaces.
Like Hashtable but unlike HashMap, this class does NOT allow null to be used as a key or value.
This class is a member of the Java Collections Framework.
Map.Entry<K,V> Constructor Summary ConcurrentHashMap()
ConcurrentHashMap(int initialCapacity)
ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)
ConcurrentHashMap(Map<? extends K,? extends V> t)
void clear()
boolean contains(Object value)
boolean containsKey(Object key)
boolean containsValue(Object value)
Enumeration<V> elements()
Set<Map.Entry<K,V>> entrySet()
V get(Object key)
boolean isEmpty()
Enumeration<K> keys()
Set<K> keySet()
V put(K key, V value)
void putAll(Map<? extends K,? extends V> t)
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()
public ConcurrentHashMap(int initialCapacity,
float loadFactor,
int concurrencyLevel)
initialCapacity - the initial capacity. The implementation performs internal sizing to accommodate this many elements.
loadFactor - the load factor threshold, used to control resizing. Resizing may be performed when the average number of elements per bin exceeds this threshold.
concurrencyLevel - the estimated number of concurrently updating threads. The implementation performs internal sizing to try to accommodate this many threads.
IllegalArgumentException - if the initial capacity is negative or the load factor or concurrencyLevel are nonpositive.
public ConcurrentHashMap(int initialCapacity)
initialCapacity - the initial capacity. The implementation performs internal sizing to accommodate this many elements.
IllegalArgumentException - if the initial capacity of elements is negative.
public ConcurrentHashMap()
public ConcurrentHashMap(Map<? extends K,? extends V> t)
t - the map
public boolean isEmpty()
AbstractMap
This implementation returns size() == 0.
isEmpty in interface Map<K,V>
isEmpty in class AbstractMap<K,V>
public int size()
AbstractMap
This implementation returns entrySet().size().
size in interface Map<K,V>
size in class AbstractMap<K,V>
public V get(Object key)
get in interface Map<K,V>
get in class AbstractMap<K,V>
key - a key in the table.
NullPointerException - if the key is null.
AbstractMap.containsKey(Object)
public boolean containsKey(Object key)
containsKey in interface Map<K,V>
containsKey in class AbstractMap<K,V>
key - possible key.
NullPointerException - if the key is null.
public boolean containsValue(Object value)
containsValue in interface Map<K,V>
containsValue in class AbstractMap<K,V>
value - value whose presence in this map is to be tested.
NullPointerException - if the value is null.
public boolean contains(Object value)
containsValue(java.lang.Object), and exists solely to ensure full compatibility with class Hashtable, which supported this method prior to introduction of the Java Collections framework.
value - a value to search for.
NullPointerException - if the value is null.
public V put(K key,
V value)
The value can be retrieved by calling the get method with a key that is equal to the original key.
put in interface Map<K,V>
put in class AbstractMap<K,V>
key - the table key.
value - the value.
NullPointerException - if the key or value is null.
public V putIfAbsent(K key,
V value)
if (!map.containsKey(key))
return map.put(key, value);
else
return map.get(key);
Except that the action is performed atomically.
putIfAbsent in interface ConcurrentMap<K,V>
key - key with which the specified value is to be associated.
value - value to be associated with the specified key.
NullPointerException - if the specified key or value is null.
public void putAll(Map<? extends K,? extends V> t)
putAll in interface Map<K,V>
putAll in class AbstractMap<K,V>
t - Mappings to be stored in this map.
public V remove(Object key)
remove in interface Map<K,V>
remove in class AbstractMap<K,V>
key - the key that needs to be removed.
NullPointerException - if the key is null.
public boolean remove(Object key,
Object value)
if (map.get(key).equals(value)) {
map.remove(key);
return true;
} else return false;
except that the action is performed atomically.
remove in interface ConcurrentMap<K,V>
key - key with which the specified value is associated.
value - value associated with the specified key.
NullPointerException - if the specified key is null.
public boolean replace(K key,
V oldValue,
V newValue)
if (map.get(key).equals(oldValue)) {
map.put(key, newValue);
return true;
} else return false;
except that the action is performed atomically.
replace in interface ConcurrentMap<K,V>
key - key with which the specified value is associated.
oldValue - value expected to be associated with the specified key.
newValue - value to be associated with the specified key.
NullPointerException - if the specified key or values are null.
public V replace(K key,
V value)
if ((map.containsKey(key)) {
return map.put(key, value);
} else return null;
except that the action is performed atomically.
replace in interface ConcurrentMap<K,V>
key - key with which the specified value is associated.
value - value to be associated with the specified key.
NullPointerException - if the specified key or value is null.
public void clear()
clear in interface Map<K,V>
clear in class AbstractMap<K,V>
public Set<K> keySet()
ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.
keySet in interface Map<K,V>
keySet in class AbstractMap<K,V>
public Collection<V> values()
ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.
values in interface Map<K,V>
values in class AbstractMap<K,V>
public Set<Map.Entry<K,V>> entrySet()
ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.
entrySet in interface Map<K,V>
entrySet in class AbstractMap<K,V>
public Enumeration<K> keys()
keySet
public Enumeration<V> elements()
values
Copyright © 2004, 2010 Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4