edu.emory.mathcs.backport.java.util.concurrent

Interface ConcurrentMap

All Superinterfaces:
Map
Known Subinterfaces:
ConcurrentNavigableMap
Known Implementing Classes:
ConcurrentHashMap, ConcurrentSkipListMap

public interface ConcurrentMap
extends Map

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 ConcurrentMap as a key or value happen-before actions subsequent to the access or removal of that object from the ConcurrentMap in another thread.

This interface is a member of the ../../../../../../../../guide/collections/index.html"> Java Collections Framework.

Author:
Doug Lea
Since:
1.5

Method Summary

Object
putIfAbsent(Object key, Object value)
If the specified key is not already associated with a value, associate it with the given value.
boolean
remove(Object key, Object value)
Removes the entry for a key only if currently mapped to a given value.
Object
replace(Object key, Object value)
Replaces the entry for a key only if currently mapped to some value.
boolean
replace(Object key, Object oldValue, Object newValue)
Replaces the entry for a key only if currently mapped to a given value.

Method Details

putIfAbsent

public Object putIfAbsent(Object key,
                          Object 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.
Parameters:
key - key with which the specified value is to be associated
value - value to be associated with the specified key
Returns:
the previous value associated with the specified key, or null if there was no mapping for the key. (A null return can also indicate that the map previously associated null with the key, if the implementation supports null values.)

remove

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.
Parameters:
key - key with which the specified value is associated
value - value expected to be associated with the specified key
Returns:
true if the value was removed

replace

public Object replace(Object key,
                      Object 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.
Parameters:
key - key with which the specified value is associated
value - value to be associated with the specified key
Returns:
the previous value associated with the specified key, or null if there was no mapping for the key. (A null return can also indicate that the map previously associated null with the key, if the implementation supports null values.)

replace

public boolean replace(Object key,
                       Object oldValue,
                       Object 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.
Parameters:
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
Returns:
true if the value was replaced