In diesem Tutorial lernen wir anhand von Beispielen die Java ConcurrentHashMap-Klasse und ihre Operationen kennen.
Die ConcurrentHashMap
Klasse des Java-Sammlungsframeworks bietet eine thread-sichere Zuordnung. Das heißt, mehrere Threads können gleichzeitig auf die Karte zugreifen, ohne die Konsistenz der Einträge in einer Karte zu beeinträchtigen.
Es implementiert die ConcurrentMap-Schnittstelle.
Erstellen Sie eine ConcurrentHashMap
Um eine gleichzeitige Hashmap zu erstellen, müssen wir java.util.concurrent.ConcurrentHashMap
zuerst das Paket importieren . Sobald wir das Paket importiert haben, können wir hier gleichzeitige Hashmaps in Java erstellen.
// ConcurrentHashMap with capacity 8 and load factor 0.6 ConcurrentHashMap numbers = new ConcurrentHashMap(8, 0.6f);
Im obigen Code haben wir eine gleichzeitige Hashmap mit dem Namen numbers erstellt.
Hier,
- Schlüssel - eine eindeutige Kennung, mit der jedes Element (Wert) in einer Karte zugeordnet wird
- Wert - Elemente, die durch Schlüssel in einer Karte verknüpft sind
Beachten Sie das Teil new ConcurrentHashMap(8, 0.6)
. Hier ist der erste Parameter die Kapazität und der zweite Parameter loadFactor .
- Kapazität - Die Kapazität dieser Karte beträgt 8. Das heißt, sie kann 8 Einträge speichern.
- loadFactor - Der Lastfaktor dieser Karte beträgt 0,6. Das heißt, wenn unsere Hash-Tabelle zu 60% gefüllt ist, werden die Einträge in eine neue Hash-Tabelle verschoben, die doppelt so groß ist wie die ursprüngliche Hash-Tabelle.
Standardkapazität und Lastfaktor
Es ist möglich, eine gleichzeitige Hashmap zu erstellen, ohne deren Kapazität und Lastfaktor zu definieren. Beispielsweise,
// ConcurrentHashMap with default capacity and load factor ConcurrentHashMap numbers1 = new ConcurrentHashMap();
Standardmäßig,
- Die Kapazität der Karte beträgt 16
- Der Lastfaktor beträgt 0,75
ConcurrentHashMap aus anderen Maps erstellen
Hier erfahren Sie, wie Sie eine gleichzeitige Hashmap erstellen können, die alle Elemente anderer Karten enthält.
import java.util.concurrent.ConcurrentHashMap; import java.util.HashMap; class Main ( public static void main(String() args) ( // Creating a hashmap of even numbers HashMap evenNumbers = new HashMap(); evenNumbers.put("Two", 2); evenNumbers.put("Four", 4); System.out.println("HashMap: " + evenNumbers); // Creating a concurrent hashmap from other map ConcurrentHashMap numbers = new ConcurrentHashMap(evenNumbers); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); ) )
Ausgabe
HashMap: (Vier = 4, Zwei = 2) ConcurrentHashMap: (Vier = 4, Zwei = 2, Drei = 3)
Methoden von ConcurrentHashMap
Die ConcurrentHashMap
Klasse bietet Methoden, mit denen wir verschiedene Operationen auf der Karte ausführen können.
Fügen Sie Elemente in ConcurrentHashMap ein
put()
- fügt die angegebene Schlüssel- / Wertzuordnung in die Zuordnung einputAll()
- fügt alle Einträge aus der angegebenen Karte in diese Karte einputIfAbsent()
- fügt die angegebene Schlüssel- / Wertzuordnung in die Karte ein, wenn der angegebene Schlüssel nicht in der Karte vorhanden ist
Beispielsweise,
import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( // Creating ConcurrentHashMap of even numbers ConcurrentHashMap evenNumbers = new ConcurrentHashMap(); // Using put() evenNumbers.put("Two", 2); evenNumbers.put("Four", 4); // Using putIfAbsent() evenNumbers.putIfAbsent("Six", 6); System.out.println("ConcurrentHashMap of even numbers: " + evenNumbers); //Creating ConcurrentHashMap of numbers ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); // Using putAll() numbers.putAll(evenNumbers); System.out.println("ConcurrentHashMap of numbers: " + numbers); ) )
Ausgabe
ConcurrentHashMap mit geraden Zahlen: (Sechs = 6, Vier = 4, Zwei = 2) ConcurrentHashMap mit Zahlen: (Sechs = 6, Eins = 1, Vier = -4, Zwei = 2)
Greifen Sie auf ConcurrentHashMap-Elemente zu
1. Verwenden Sie entrySet (), keySet () und values ()
entrySet()
- gibt einen Satz aller Schlüssel- / Wertzuordnungen der Karte zurückkeySet()
- gibt einen Satz aller Schlüssel der Karte zurückvalues()
- gibt einen Satz aller Werte der Karte zurück
Beispielsweise,
import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // Using entrySet() System.out.println("Key/Value mappings: " + numbers.entrySet()); // Using keySet() System.out.println("Keys: " + numbers.keySet()); // Using values() System.out.println("Values: " + numbers.values()); ) )
Ausgabe
ConcurrentHashMap: (Eins = 1, Zwei = 2, Drei = 3) Schlüssel- / Wertzuordnungen: (Eins = 1, Zwei = 2, Drei = 3) Schlüssel: (Eins, Zwei, Drei) Werte: (1, 2, 3 )
2. Verwenden Sie get () und getOrDefault ()
get()
- Gibt den Wert zurück, der dem angegebenen Schlüssel zugeordnet ist. Gibt zurück,null
wenn der Schlüssel nicht gefunden wird.getOrDefault()
- Gibt den Wert zurück, der dem angegebenen Schlüssel zugeordnet ist. Gibt den angegebenen Standardwert zurück, wenn der Schlüssel nicht gefunden wird.
Beispielsweise,
import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // Using get() int value1 = numbers.get("Three"); System.out.println("Using get(): " + value1); // Using getOrDefault() int value2 = numbers.getOrDefault("Five", 5); System.out.println("Using getOrDefault(): " + value2); ) )
Ausgabe
ConcurrentHashMap: (Eins = 1, Zwei = 2, Drei = 3) Verwenden von get (): 3 Verwenden von getOrDefault (): 5
Entfernen Sie ConcurrentHashMap-Elemente
remove(key)
- gibt den mit dem angegebenen Schlüssel verknüpften Eintrag zurück und entfernt ihn aus der Karteremove(key, value)
- removes the entry from the map only if the specified key mapped to the specified value and return a boolean value
For example,
import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // remove method with single parameter int value = numbers.remove("Two"); System.out.println("Removed value: " + value); // remove method with two parameters boolean result = numbers.remove("Three", 3); System.out.println("Is the entry (Three=3) removed? " + result); System.out.println("Updated ConcurrentHashMap: " + numbers); ) )
Output
ConcurrentHashMap: (One=1, Two=2, Three=3) Removed value: 2 Is the entry (Three=3) removed? True Updated ConcurrentHashMap: (One=1)
Bulk ConcurrentHashMap Operations
The ConcurrentHashMap
class provides different bulk operations that can be applied safely to concurrent maps.
1. forEach() Method
The forEach()
method iterates over our entries and executes the specified function.
It includes two parameters.
- parallelismThreshold - It specifies that after how many elements operations in a map are executed in parallel.
- transformer - This will transform the data before the data is passed to the specified function.
For example,
import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // forEach() without transformer function numbers.forEach(4, (k, v) -> System.out.println("key: " + k + " value: " + v)); // forEach() with transformer function System.out.print("Values are "); numbers.forEach(4, (k, v) -> v, (v) -> System.out.print(v + ", ")); ) )
Output
ConcurrentHashMap: (One = 1, Two = 2, Three = 3) key: One value: 1 key: Two value: 2 key: Three value: 3 Values are 1, 2, 3,
In the above program, we have used parallel threshold 4. This means if the map contains 4 entries, the operation will be executed in parallel.
Variation of forEach() Method
forEachEntry()
- executes the specified function for each entryforEachKey()
- executes the specified function for each keyforEachValue()
- executes the specified function for each value
2. search() Method
The search()
method searches the map based on the specified function and returns the matched entry.
Here, the specified function determines what entry is to be searched.
It also includes an optional parameter parallelThreshold. The parallel threshold specifies that after how many elements in the map the operation is executed in parallel.
For example,
import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // Using search() String key = numbers.search(4, (k, v) -> (return v == 3 ? k: null;)); System.out.println("Searched value: " + key); ) )
Output
ConcurrentHashMap: (One=1, Two=2, Three=3) Searched value: Three
Variants of search() Method
searchEntries()
- search function is applied to key/value mappingssearchKeys()
- search function is only applied to the keyssearchValues()
- search function is only applied to the values
3. reduce() Method
The reduce()
method accumulates (gather together) each entry in a map. This can be used when we need all the entries to perform a common task, like adding all the values of a map.
It includes two parameters.
- parallelismThreshold - It specifies that after how many elements, operations in a map are executed in parallel.
- transformer - This will transform the data before the data is passed to the specified function.
For example,
import java.util.concurrent.ConcurrentHashMap; class Main ( public static void main(String() args) ( ConcurrentHashMap numbers = new ConcurrentHashMap(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); // Using search() int sum = numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1 + v2); System.out.println("Sum of all values: " + sum); ) )
Output
ConcurrentHashMap: (One=1, Two=2, Three=3) Sum of all values: 6
In the above program, notice the statement
numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1+v2);
Here,
- 4 is a parallel threshold
- (k, v) -> v is a transformer function. It transfers the key/value mappings into values only.
- (v1, v2) -> v1+v2 is a reducer function. It gathers together all the values and adds all values.
Variants of reduce() Method
reduceEntries()
- returns the result of gathering all the entries using the specified reducer functionreduceKeys()
- returns the result of gathering all the keys using the specified reducer functionreduceValues()
- returns the result of gathering all the values using the specified reducer function
ConcurrentHashMap vs HashMap
Here are some of the differences between ConcurrentHashMap
and HashMap,
ConcurrentHashMap
is a thread-safe collection. That is, multiple threads can access and modify it at the same time.ConcurrentHashMap
provides methods for bulk operations likeforEach()
,search()
andreduce()
.
Why ConcurrentHashMap?
- Die
ConcurrentHashMap
Klasse ermöglicht es mehreren Threads, gleichzeitig auf ihre Einträge zuzugreifen. - Standardmäßig ist die gleichzeitige Hashmap in 16 Segmente unterteilt . Dies ist der Grund, warum 16 Threads gleichzeitig die Map ändern dürfen. Es können jedoch beliebig viele Threads gleichzeitig auf die Karte zugreifen.
- Die
putIfAbsent()
Methode überschreibt den Eintrag in der Karte nicht, wenn der angegebene Schlüssel bereits vorhanden ist. - Es bietet eine eigene Synchronisation.