Java ConcurrentMap Interface

In diesem Tutorial werden wir das Java ConcurrentMap-Interface und seine Methoden lernen.

Das ConcurrentMap-Interface der Java-Sammelrahmen bietet threadsichere Abbildungen. Das bedeutet, dass mehrere Threads gleichzeitig auf diese Abbildung zugreifen können, ohne die Konsistenz der Einträge im Abbildung zu beeinträchtigen.

ConcurrentMap wird als Synchronmap bezeichnet.

Es erbt vonMap-Interface.

Klassen, die ConcurrentMap implementieren

Da ConcurrentMap ein Interface ist, kann aus ihm kein Objekt erstellt werden.

Um die Funktionen des ConcurrentMap-Interfaces zu nutzen, müssen wir die Klasse ConcurrentHashMap verwenden, die das Interface implementiert.

Wie verwendet man ConcurrentMap?}

Um ConcurrentMap zu verwenden, müssen wir zunächst das Paket java.util.concurrent.ConcurrentMap importieren. Nach dem Importieren des Pakets wird ein paralleles Mapping wie folgt erstellt.

//　Verwendung der ConcurrentHashMap-Klasse
ConcurrentMap<Key, Value> numbers = new ConcurrentHashMap<>();

In dem obigen Code haben wir eine ConcurrentMap namens numbers erstellt.

Hier,

• Key - Ein einzigartiger Identifikator, um jedes Element (Wert) im Map zu verknüpfen

• Value - Elemente im Map, die mit einem Schlüssel verknüpft sind

Methoden von ConcurrentMap

Das ConcurrentMap-Interface enthält alle Methoden des Map-Interfaces. Dies liegt daran, dass Map das Super-Interface des ConcurrentMap-Interfaces ist.

Neben all diesen Methoden gibt es auch spezifische Methoden für das ConcurrentMap-Interface.

• putIfAbsent() - Fügt einen bestimmten Schlüssel hinzu, falls dieser noch nicht mit einem Wert verknüpft ist,/Wert wird in die Abbildung eingefügt.

• compute() - Berechnet einen Eintrag (Schlüssel/Wertzuordnung).

• computeIfAbsent() - Berechnet einen Wert für einen bestimmten Schlüssel, falls dieser noch nicht mit einem Wert verknüpft ist, indem eine bestimmte Funktion verwendet wird.

• computeIfPresent() - Berechnet einen neuen Eintrag (Schlüssel/Wertzuordnung).

• forEach() - Durchsucht alle Einträge im Map und führt eine bestimmte Operation aus.

• merge() -Fügt eine neue Werteinstellung zu einem bestimmten Schlüssel hinzu, falls dieser bereits einen Wert hat. Falls der Schlüssel noch nicht vorhanden ist, wird der angegebene Wert mit dem Schlüssel verknüpft.

Die Implementierung von ConcurrentMap in ConcurrentHashMap

import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Mit ConcurrentMap<String, Integer> numbers = new ConcurrentHashMap<>(); wird ein ConcurrentMap erstellt.
　　　　　　　　ConcurrentMap<String, Integer> numbers = new ConcurrentHashMap<>();
　　　　　　　　//　Elemente in das Map einfügen
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("ConcurrentMap: ");　+　numbers);
　　　　　　　　//Angegebene Schlüssel abrufen
　　　　　　　　int value = numbers.get("One");
　　　　　　　　System.out.println("Besuchte Wert: ");　+　value);
　　　　　　　　//Wert mit angegebenem Schlüssel löschen
　　　　　　　　int removedValue = numbers.remove("Two");
　　　　　　　　System.out.println("Gelöschter Wert: ");　+　removedValue);
　　　　}
}

Ausgaberesultat

ConcurrentMap: {One=1, Two=2, Three=3}
Besuchte Wert:　1
Gelöschter Wert:　2

Um mehr über ConcurrentHashMap zu erfahren, besuchen Sie bitteJava ConcurrentHashMap.