Package java.util.concurrent

Interface ConcurrentMap<K,​V>

Type Parameters:
K - the type of keys maintained by this map
V - the type of mapped values
All Superinterfaces:
Map<K,​V>
All Known Subinterfaces:
ConcurrentNavigableMap<K,​V>
All Known Implementing Classes:
ConcurrentHashMap, ConcurrentSkipListMap
public interface ConcurrentMap<K,​V>
extends Map<K,​V>
A 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.

Since:
1.5
Author:
Doug Lea

  • Nested Class Summary

    Nested classes/interfaces inherited from interface java.util.Map

    Map.Entry<K,​V>

  • Method Summary

    Modifier and Type Method Description
    V putIfAbsent​(K key, V 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.
    V replace​(K key, V value)
    Replaces the entry for a key only if currently mapped to some value.
    boolean replace​(K key, V oldValue, V newValue)
    Replaces the entry for a key only if currently mapped to a given value.

    Methods inherited from interface java.util.Map

    clear, containsKey, containsValue, entrySet, equals, get, hashCode, isEmpty, keySet, put, putAll, remove, size, values

  • Method Details

    • putIfAbsent

      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.
      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.)
      Throws:
      UnsupportedOperationException - if the put operation is not supported by this map
      ClassCastException - if the class of the specified key or value prevents it from being stored in this map
      NullPointerException - if the specified key or value is null, and this map does not permit null keys or values
      IllegalArgumentException - if some property of the specified key or value prevents it from being stored in this map

    • remove

      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
      Throws:
      UnsupportedOperationException - if the remove operation is not supported by this map
      ClassCastException - if the key or value is of an inappropriate type for this map (optional)
      NullPointerException - if the specified key or value is null, and this map does not permit null keys or values (optional)

    • replace

      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.
      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
      Throws:
      UnsupportedOperationException - if the put operation is not supported by this map
      ClassCastException - if the class of a specified key or value prevents it from being stored in this map
      NullPointerException - if a specified key or value is null, and this map does not permit null keys or values
      IllegalArgumentException - if some property of a specified key or value prevents it from being stored in this map

    • replace

      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.
      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.)
      Throws:
      UnsupportedOperationException - if the put operation is not supported by this map
      ClassCastException - if the class of the specified key or value prevents it from being stored in this map
      NullPointerException - if the specified key or value is null, and this map does not permit null keys or values
      IllegalArgumentException - if some property of the specified key or value prevents it from being stored in this map