This class is a threadsafe implementation of
the java.util.Map interface, and of the atomic
operations added by the ConcurrentMap interface.
This class is intended as a drop-in replacement for
java.util.Hashtable. It is more efficient than
that class, however, because it provides threadsafety without using
synchronized methods that lock the entire data
structure. ConcurrentHashMap allows any number of
concurrent read operations without locking. Locking is required for
updates to a ConcurrentHashMap, but the internal
data structure is segmented so that only the segment being updated is
locked, and reads and writes can proceed concurrently in other
segments. You can specify the number of internal segments with the
concurrencyLevel argument to the
constructor. The default is 16. Set this to the approximate number of
updater threads you expect to access the data structure. Like
Hashtable, ConcurrentHashMap
does not allow null keys or values. (Note that
this differs from the behavior of
java.util.HashMap.)
public class
ConcurrentHashMap<K,V> extends java.util.AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable {
// Public Constructors
public
ConcurrentHashMap ( );
public
ConcurrentHashMap (java.util.Map<? extends K,? extends V>
t );
public
ConcurrentHashMap (int
initialCapacity );
public
ConcurrentHashMap (int
initialCapacity , float
loadFactor , int
concurrencyLevel );
// Public Instance Methods
public boolean
contains (Object
value );
public java.util.Enumeration<V>
elements ( );
public java.util.Enumeration<K>
keys ( );
// Methods Implementing ConcurrentMap
public V
putIfAbsent (K
key , V
value );
public boolean
remove (Object
key , Object
value );
public V
replace (K
key , V
value );
public boolean
replace (K
key , V
oldValue , V
newValue );
// Methods Implementing Map
public void
clear ( );
public boolean
containsKey (Object
key );
public boolean
containsValue (Object
value );
public java.util.Set<java.util.Map.Entry<K,V>>
entrySet ( );
public V
get (Object
key );
public boolean
isEmpty ( ); default:true
public java.util.Set<K>
keySet ( );
public V
put (K
key , V
value );
public void
putAll (java.util.Map<? extends K,? extends V>
t );
public V
remove (Object
key );
public int
size ( );
public java.util.Collection<V>
values ( );
}