Save This Page
Home » openjdk-7 » java » util » concurrent » [javadoc | source]
java.util.concurrent
public class: ConcurrentHashMap [javadoc | source]
java.lang.Object
   java.util.AbstractMap<K, V>
      java.util.concurrent.ConcurrentHashMap

All Implemented Interfaces:
    ConcurrentMap, java$io$Serializable, Map

A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updates. This class obeys the same functional specification as java.util.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.

Nested Class Summary:
static final class  ConcurrentHashMap.HashEntry  ConcurrentHashMap list entry. Note that this is never exported out as a user-visible Map.Entry. 
static final class  ConcurrentHashMap.Segment  Segments are specialized versions of hash tables. This subclasses from ReentrantLock opportunistically, just to simplify some locking and avoid separate construction. 
abstract class  ConcurrentHashMap.HashIterator   
final class  ConcurrentHashMap.KeyIterator   
final class  ConcurrentHashMap.ValueIterator   
final class  ConcurrentHashMap.WriteThroughEntry  Custom Entry class used by EntryIterator.next(), that relays setValue changes to the underlying map. 
final class  ConcurrentHashMap.EntryIterator   
final class  ConcurrentHashMap.KeySet   
final class  ConcurrentHashMap.Values   
final class  ConcurrentHashMap.EntrySet   
Field Summary
static final  int DEFAULT_INITIAL_CAPACITY    The default initial capacity for this table, used when not otherwise specified in a constructor. 
static final  float DEFAULT_LOAD_FACTOR    The default load factor for this table, used when not otherwise specified in a constructor. 
static final  int DEFAULT_CONCURRENCY_LEVEL    The default concurrency level for this table, used when not otherwise specified in a constructor. 
static final  int MAXIMUM_CAPACITY    The maximum capacity, used if a higher value is implicitly specified by either of the constructors with arguments. MUST be a power of two <= 1<<30 to ensure that entries are indexable using ints. 
static final  int MIN_SEGMENT_TABLE_CAPACITY    The minimum capacity for per-segment tables. Must be a power of two, at least two to avoid immediate resizing on next use after lazy construction. 
static final  int MAX_SEGMENTS    The maximum number of segments to allow; used to bound constructor arguments. Must be power of two less than 1 << 24. 
static final  int RETRIES_BEFORE_LOCK    Number of unsynchronized retries in size and containsValue methods before resorting to locking. This is used to avoid unbounded retries if tables undergo continuous modification which would make it impossible to obtain an accurate result. 
final  int segmentMask    Mask value for indexing into segments. The upper bits of a key's hash code are used to choose the segment. 
final  int segmentShift    Shift value for indexing within segments. 
final  Segment<K, V>[] segments    The segments, each of which is a specialized hash table. 
transient  Set<K> keySet     
transient  Set<K, V> entrySet     
transient  Collection<V> values     
Fields inherited from java.util.AbstractMap:
keySet,  values
Constructor:
 public ConcurrentHashMap() 
 public ConcurrentHashMap(int initialCapacity) 
 public ConcurrentHashMap(Map<? extends K, ? extends V> m) 
    Creates a new map with the same mappings as the given map. The map is created with a capacity of 1.5 times the number of mappings in the given map or 16 (whichever is greater), and a default load factor (0.75) and concurrencyLevel (16).
    Parameters:
    m - the map
 public ConcurrentHashMap(int initialCapacity,
    float loadFactor) 
 public ConcurrentHashMap(int initialCapacity,
    float loadFactor,
    int concurrencyLevel) 
Method from java.util.concurrent.ConcurrentHashMap Summary:
clear,   contains,   containsKey,   containsValue,   elements,   entryAt,   entryForHash,   entrySet,   get,   isEmpty,   keySet,   keys,   put,   putAll,   putIfAbsent,   remove,   remove,   replace,   replace,   segmentAt,   setEntryAt,   size,   values
Methods from java.util.AbstractMap:
clear,   clone,   containsKey,   containsValue,   entrySet,   equals,   get,   hashCode,   isEmpty,   keySet,   put,   putAll,   remove,   size,   toString,   values
Methods from java.lang.Object:
clone,   equals,   finalize,   getClass,   hashCode,   notify,   notifyAll,   toString,   wait,   wait,   wait
Method from java.util.concurrent.ConcurrentHashMap Detail:
 public  void clear() 
    Removes all of the mappings from this map.
 public boolean contains(Object value) 
    Legacy method testing if some key maps into the specified value in this table. This method is identical in functionality to #containsValue , and exists solely to ensure full compatibility with class java.util.Hashtable , which supported this method prior to introduction of the Java Collections framework.
 public boolean containsKey(Object key) 
    Tests if the specified object is a key in this table.
 public boolean containsValue(Object value) 
    Returns true if this map maps one or more keys to the specified value. Note: This method requires a full internal traversal of the hash table, and so is much slower than method containsKey.
 public Enumeration<V> elements() 
    Returns an enumeration of the values in this table.
 static final HashEntry<K, V> entryAt(HashEntry<K, V>[] tab,
    int i) 
    Gets the ith element of given table (if nonnull) with volatile read semantics. Note: This is manually integrated into a few performance-sensitive methods to reduce call overhead.
 static final HashEntry<K, V> entryForHash(Segment<K, V> seg,
    int h) 
    Gets the table entry for the given segment and hash
 public Set<K, V> entrySet() 
    Returns a Set view of the mappings contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.

    The view's iterator is a "weakly consistent" iterator that will never throw 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.

 public V get(Object key) 
    Returns the value to which the specified key is mapped, or {@code null} if this map contains no mapping for the key.

    More formally, if this map contains a mapping from a key {@code k} to a value {@code v} such that {@code key.equals(k)}, then this method returns {@code v}; otherwise it returns {@code null}. (There can be at most one such mapping.)

 public boolean isEmpty() 
    Returns true if this map contains no key-value mappings.
 public Set<K> keySet() 
    Returns a Set view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. The set supports element removal, which removes the corresponding mapping from this map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.

    The view's iterator is a "weakly consistent" iterator that will never throw 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.

 public Enumeration<K> keys() 
    Returns an enumeration of the keys in this table.
 public V put(K key,
    V value) 
    Maps the specified key to the specified value in this table. Neither the key nor the value can be null.

    The value can be retrieved by calling the get method with a key that is equal to the original key.

 public  void putAll(Map<? extends K, ? extends V> m) 
    Copies all of the mappings from the specified map to this one. These mappings replace any mappings that this map had for any of the keys currently in the specified map.
 public V putIfAbsent(K key,
    V value) 
    {@inheritDoc}
 public V remove(Object key) 
    Removes the key (and its corresponding value) from this map. This method does nothing if the key is not in the map.
 public boolean remove(Object key,
    Object value) 
    {@inheritDoc}
 public V replace(K key,
    V value) 
    {@inheritDoc}
 public boolean replace(K key,
    V oldValue,
    V newValue) 
    {@inheritDoc}
 static final Segment<K, V> segmentAt(Segment<K, V>[] ss,
    int j) 
    Gets the jth element of given segment array (if nonnull) with volatile element access semantics via Unsafe. (The null check can trigger harmlessly only during deserialization.) Note: because each element of segments array is set only once (using fully ordered writes), some performance-sensitive methods rely on this method only as a recheck upon null reads.
 static final  void setEntryAt(HashEntry<K, V>[] tab,
    int i,
    HashEntry<K, V> e) 
    Sets the ith element of given table, with volatile write semantics. (See above about use of putOrderedObject.)
 public int size() 
    Returns the number of key-value mappings in this map. If the map contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE.
 public Collection<V> values() 
    Returns a Collection view of the values contained in this map. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. The collection supports element removal, which removes the corresponding mapping from this map, via the Iterator.remove, Collection.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.

    The view's iterator is a "weakly consistent" iterator that will never throw 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.