java.util.concurrent

Interface ConcurrentMap<K,V>

Inhaltsverzeichnis
  • 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.

    This interface is a member of the Java Collections Framework.

    Since:
    1.5

    • Method Detail

      • 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

Deutsche Übersetzung

Sie haben gebeten, diese Seite auf Deutsch zu besuchen. Momentan ist nur die Oberfläche übersetzt, aber noch nicht der gesamte Inhalt.

Wenn Sie mir bei Übersetzungen helfen wollen, ist Ihr Beitrag willkommen. Alles, was Sie tun müssen, ist, sich auf der Website zu registrieren und mir eine Nachricht zu schicken, in der Sie gebeten werden, Sie der Gruppe der Übersetzer hinzuzufügen, die Ihnen die Möglichkeit gibt, die gewünschten Seiten zu übersetzen. Ein Link am Ende jeder übersetzten Seite zeigt an, dass Sie der Übersetzer sind und einen Link zu Ihrem Profil haben.

Vielen Dank im Voraus.

Dokument erstellt 11/06/2005, zuletzt geändert 04/03/2020
Quelle des gedruckten Dokuments:https://www.gaudry.be/de/java-api-rf-java/util/concurrent/concurrentmap.html

Die Infobro ist eine persönliche Seite, deren Inhalt in meiner alleinigen Verantwortung liegt. Der Text ist unter der CreativeCommons-Lizenz (BY-NC-SA) verfügbar. Weitere Informationen auf die Nutzungsbedingungen und dem Autor.

Referenzen

  1. Zeigen Sie - html-Dokument Sprache des Dokuments:fr Manuel PHP : https://docs.oracle.com

Diese Verweise und Links verweisen auf Dokumente, die während des Schreibens dieser Seite konsultiert wurden, oder die zusätzliche Informationen liefern können, aber die Autoren dieser Quellen können nicht für den Inhalt dieser Seite verantwortlich gemacht werden.
Der Autor Diese Website ist allein dafür verantwortlich, wie die verschiedenen Konzepte und Freiheiten, die mit den Nachschlagewerken gemacht werden, hier dargestellt werden. Denken Sie daran, dass Sie mehrere Quellinformationen austauschen müssen, um das Risiko von Fehlern zu reduzieren.

Inhaltsverzeichnis Haut