Save This Page
Home » openjdk-7 » java » util » concurrent » [javadoc | source]
java.util.concurrent
public interface: ConcurrentMap [javadoc | source]

All Implemented Interfaces:
    Map

All Known Implementing Classes:
    ConcurrentNavigableMap, ConcurrentSkipListMap, ConcurrentHashMap, SubMap

A java.util.Map providing additional atomic putIfAbsent, remove, and replace methods.

Memory consistency effects: As with other concurrent collections, actions in a thread prior to placing an object into a {@code ConcurrentMap} as a key or value happen-before actions subsequent to the access or removal of that object from the {@code ConcurrentMap} in another thread.

This interface is a member of the Java Collections Framework.

Method from java.util.concurrent.ConcurrentMap Summary:
putIfAbsent,   remove,   replace,   replace
Method from java.util.concurrent.ConcurrentMap Detail:
 public V putIfAbsent(K key,
    V value)
    If the specified key is not already associated
with a value, associate it with the given value.
This is equivalent to

    if (!map.containsKey(key))
return map.put(key, value);
else
return map.get(key);
    
except that the action is performed atomically.
 public boolean remove(Object key,
    Object value)
    Removes the entry for a key only if currently mapped to a given value.
This is equivalent to

    if (map.containsKey(key) && map.get(key).equals(value)) {
map.remove(key);
return true;
} else return false;
    
except that the action is performed atomically.
 public V replace(K key,
    V value)
    Replaces the entry for a key only if currently mapped to some value.
This is equivalent to

    if (map.containsKey(key)) {
return map.put(key, value);
} else return null;
    
except that the action is performed atomically.
 public boolean replace(K key,
    V oldValue,
    V newValue)
    Replaces the entry for a key only if currently mapped to a given value.
This is equivalent to

    if (map.containsKey(key) && map.get(key).equals(oldValue)) {
map.put(key, newValue);
return true;
} else return false;
    
except that the action is performed atomically.