Module java.base

Interface ConcurrentMap<K,V>

  • Type Parameters:
    K - the type of keys maintained by this map
    V - the type of mapped values
    All Superinterfaces:
    java.util.Map<K,V>
    All Known Subinterfaces:
    ConcurrentNavigableMap<K,V>
    All Known Implementing Classes:
    ConcurrentHashMap, ConcurrentSkipListMap


    public interface ConcurrentMap<K,V>
    extends java.util.Map<K,V>
    A Map providing thread safety and atomicity guarantees.

    To maintain the specified guarantees, default implementations of methods including putIfAbsent(K, V) inherited from Map must be overridden by implementations of this interface. Similarly, implementations of the collections returned by methods Map.keySet(), Map.values(), and Map.entrySet() must override methods such as removeIf when necessary to preserve atomicity guarantees.

    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 Java Collections Framework.

    Since:
    1.5
    Author:
    Doug Lea
    • Nested Class Summary

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

        java.util.Map.Entry<K extends java.lang.Object,V extends java.lang.Object>
    • Method Summary

      All Methods Instance Methods Abstract Methods Default Methods 
      Modifier and Type Method Description
      default V compute​(K key, java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction)
      default V computeIfAbsent​(K key, java.util.function.Function<? super K,? extends V> mappingFunction)
      default V computeIfPresent​(K key, java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction)
      default void forEach​(java.util.function.BiConsumer<? super K,? super V> action)
      default V getOrDefault​(java.lang.Object key, V defaultValue)
      default V merge​(K key, V value, java.util.function.BiFunction<? super V,? super V,? extends V> remappingFunction)
      V putIfAbsent​(K key, V value)
      If the specified key is not already associated with a value, associates it with the given value.
      boolean remove​(java.lang.Object key, java.lang.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.
      default void replaceAll​(java.util.function.BiFunction<? super K,? super V,? extends V> function)
      • Methods inherited from interface java.util.Map

        clear, containsKey, containsValue, entry, entrySet, equals, get, hashCode, isEmpty, keySet, of, of, of, of, of, of, of, of, of, of, of, ofEntries, put, putAll, remove, size, values
    • Method Detail

      • getOrDefault

        default V getOrDefault​(java.lang.Object key,
                               V defaultValue)
        Specified by:
        getOrDefault in interface java.util.Map<K,V>
        Throws:
        java.lang.ClassCastException
        java.lang.NullPointerException
        Since:
        1.8
        Implementation Note:
        This implementation assumes that the ConcurrentMap cannot contain null values and get() returning null unambiguously means the key is absent. Implementations which support null values must override this default implementation.
      • forEach

        default void forEach​(java.util.function.BiConsumer<? super K,? super V> action)
        Specified by:
        forEach in interface java.util.Map<K,V>
        Throws:
        java.lang.NullPointerException
        Since:
        1.8
        Implementation Requirements:
        The default implementation is equivalent to, for this map:
         
         for (Map.Entry<K,V> entry : map.entrySet()) {
           action.accept(entry.getKey(), entry.getValue());
         }
        Implementation Note:
        The default implementation assumes that IllegalStateException thrown by getKey() or getValue() indicates that the entry has been removed and cannot be processed. Operation continues for subsequent entries.
      • putIfAbsent

        V putIfAbsent​(K key,
                      V value)
        If the specified key is not already associated with a value, associates it with the given value. This is equivalent to, for this map:
         
         if (!map.containsKey(key))
           return map.put(key, value);
         else
           return map.get(key);
        except that the action is performed atomically.
        Specified by:
        putIfAbsent in interface java.util.Map<K,V>
        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:
        java.lang.UnsupportedOperationException - if the put operation is not supported by this map
        java.lang.ClassCastException - if the class of the specified key or value prevents it from being stored in this map
        java.lang.NullPointerException - if the specified key or value is null, and this map does not permit null keys or values
        java.lang.IllegalArgumentException - if some property of the specified key or value prevents it from being stored in this map
        Implementation Note:
        This implementation intentionally re-abstracts the inappropriate default provided in Map.
      • remove

        boolean remove​(java.lang.Object key,
                       java.lang.Object value)
        Removes the entry for a key only if currently mapped to a given value. This is equivalent to, for this map:
         
         if (map.containsKey(key)
             && Objects.equals(map.get(key), value)) {
           map.remove(key);
           return true;
         } else {
           return false;
         }
        except that the action is performed atomically.
        Specified by:
        remove in interface java.util.Map<K,V>
        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:
        java.lang.UnsupportedOperationException - if the remove operation is not supported by this map
        java.lang.ClassCastException - if the key or value is of an inappropriate type for this map (optional)
        java.lang.NullPointerException - if the specified key or value is null, and this map does not permit null keys or values (optional)
        Implementation Note:
        This implementation intentionally re-abstracts the inappropriate default provided in Map.
      • 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, for this map:
         
         if (map.containsKey(key)
             && Objects.equals(map.get(key), oldValue)) {
           map.put(key, newValue);
           return true;
         } else {
           return false;
         }
        except that the action is performed atomically.
        Specified by:
        replace in interface java.util.Map<K,V>
        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:
        java.lang.UnsupportedOperationException - if the put operation is not supported by this map
        java.lang.ClassCastException - if the class of a specified key or value prevents it from being stored in this map
        java.lang.NullPointerException - if a specified key or value is null, and this map does not permit null keys or values
        java.lang.IllegalArgumentException - if some property of a specified key or value prevents it from being stored in this map
        Implementation Note:
        This implementation intentionally re-abstracts the inappropriate default provided in 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, for this map:
         
         if (map.containsKey(key))
           return map.put(key, value);
         else
           return null;
        except that the action is performed atomically.
        Specified by:
        replace in interface java.util.Map<K,V>
        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:
        java.lang.UnsupportedOperationException - if the put operation is not supported by this map
        java.lang.ClassCastException - if the class of the specified key or value prevents it from being stored in this map
        java.lang.NullPointerException - if the specified key or value is null, and this map does not permit null keys or values
        java.lang.IllegalArgumentException - if some property of the specified key or value prevents it from being stored in this map
        Implementation Note:
        This implementation intentionally re-abstracts the inappropriate default provided in Map.
      • replaceAll

        default void replaceAll​(java.util.function.BiFunction<? super K,? super V,? extends V> function)
        Specified by:
        replaceAll in interface java.util.Map<K,V>
        Throws:
        java.lang.UnsupportedOperationException
        java.lang.NullPointerException
        java.lang.ClassCastException
        java.lang.IllegalArgumentException
        Since:
        1.8
        Implementation Requirements:

        The default implementation is equivalent to, for this map:

         
         for (Map.Entry<K,V> entry : map.entrySet()) {
           K k;
           V v;
           do {
             k = entry.getKey();
             v = entry.getValue();
           } while (!map.replace(k, v, function.apply(k, v)));
         }
        The default implementation may retry these steps when multiple threads attempt updates including potentially calling the function repeatedly for a given key.

        This implementation assumes that the ConcurrentMap cannot contain null values and get() returning null unambiguously means the key is absent. Implementations which support null values must override this default implementation.

      • computeIfAbsent

        default V computeIfAbsent​(K key,
                                  java.util.function.Function<? super K,? extends V> mappingFunction)
        Specified by:
        computeIfAbsent in interface java.util.Map<K,V>
        Throws:
        java.lang.UnsupportedOperationException
        java.lang.ClassCastException
        java.lang.NullPointerException
        java.lang.IllegalArgumentException
        Since:
        1.8
        Implementation Requirements:
        The default implementation is equivalent to the following steps for this map:
         
         V oldValue, newValue;
         return ((oldValue = map.get(key)) == null
                 && (newValue = mappingFunction.apply(key)) != null
                 && (oldValue = map.putIfAbsent(key, newValue)) == null)
           ? newValue
           : oldValue;

        This implementation assumes that the ConcurrentMap cannot contain null values and get() returning null unambiguously means the key is absent. Implementations which support null values must override this default implementation.

      • computeIfPresent

        default V computeIfPresent​(K key,
                                   java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction)
        Specified by:
        computeIfPresent in interface java.util.Map<K,V>
        Throws:
        java.lang.UnsupportedOperationException
        java.lang.ClassCastException
        java.lang.NullPointerException
        java.lang.IllegalArgumentException
        Since:
        1.8
        Implementation Requirements:
        The default implementation is equivalent to performing the following steps for this map:
         
         for (V oldValue; (oldValue = map.get(key)) != null; ) {
           V newValue = remappingFunction.apply(key, oldValue);
           if ((newValue == null)
               ? map.remove(key, oldValue)
               : map.replace(key, oldValue, newValue))
             return newValue;
         }
         return null;
        When multiple threads attempt updates, map operations and the remapping function may be called multiple times.

        This implementation assumes that the ConcurrentMap cannot contain null values and get() returning null unambiguously means the key is absent. Implementations which support null values must override this default implementation.

      • compute

        default V compute​(K key,
                          java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction)
        Specified by:
        compute in interface java.util.Map<K,V>
        Throws:
        java.lang.UnsupportedOperationException
        java.lang.ClassCastException
        java.lang.NullPointerException
        java.lang.IllegalArgumentException
        Since:
        1.8
        Implementation Requirements:
        The default implementation is equivalent to performing the following steps for this map:
         
         for (;;) {
           V oldValue = map.get(key);
           V newValue = remappingFunction.apply(key, oldValue);
           if (newValue != null) {
             if ((oldValue != null)
               ? map.replace(key, oldValue, newValue)
               : map.putIfAbsent(key, newValue) == null)
               return newValue;
           } else if (oldValue == null || map.remove(key, oldValue)) {
             return null;
           }
         }
        When multiple threads attempt updates, map operations and the remapping function may be called multiple times.

        This implementation assumes that the ConcurrentMap cannot contain null values and get() returning null unambiguously means the key is absent. Implementations which support null values must override this default implementation.

      • merge

        default V merge​(K key,
                        V value,
                        java.util.function.BiFunction<? super V,? super V,? extends V> remappingFunction)
        Specified by:
        merge in interface java.util.Map<K,V>
        Throws:
        java.lang.UnsupportedOperationException
        java.lang.ClassCastException
        java.lang.NullPointerException
        java.lang.IllegalArgumentException
        Since:
        1.8
        Implementation Requirements:
        The default implementation is equivalent to performing the following steps for this map:
         
         for (;;) {
           V oldValue = map.get(key);
           if (oldValue != null) {
             V newValue = remappingFunction.apply(oldValue, value);
             if (newValue != null) {
               if (map.replace(key, oldValue, newValue))
                 return newValue;
             } else if (map.remove(key, oldValue)) {
               return null;
             }
           } else if (map.putIfAbsent(key, value) == null) {
             return value;
           }
         }
        When multiple threads attempt updates, map operations and the remapping function may be called multiple times.

        This implementation assumes that the ConcurrentMap cannot contain null values and get() returning null unambiguously means the key is absent. Implementations which support null values must override this default implementation.