I denne vejledning lærer vi om Java ConcurrentHashMap-klassen og dens operationer ved hjælp af eksempler.
Den ConcurrentHashMap
klasse af Java kollektioner rammer giver en tråd-safe kortet. Det vil sige, at flere tråde kan få adgang til kortet på en gang uden at påvirke konsistensen af poster på et kort.
Det implementerer ConcurrentMap-grænsefladen.
Opret et ConcurrentHashMap
For at oprette en samtidig hashmap skal vi først importere java.util.concurrent.ConcurrentHashMap
pakken. Når vi først har importeret pakken, kan du oprette samtidige hashmaps i Java.
// ConcurrentHashMap with capacity 8 and load factor 0.6 ConcurrentHashMap numbers = new ConcurrentHashMap(8, 0.6f);
I ovenstående kode har vi oprettet et sideløbende hashmap med navn.
Her,
- Nøgle - en unik identifikator, der bruges til at knytte hvert element (værdi) til et kort
- Værdi - elementer tilknyttet nøgler på et kort
Læg mærke til delen new ConcurrentHashMap(8, 0.6)
. Her er den første parameter kapacitet, og den anden parameter er loadFactor .
- Kapacitet - Kortets kapacitet er 8. Det betyder, at det kan gemme 8 poster.
- loadFactor - Belastningsfaktoren på dette kort er 0,6. Dette betyder, at hver gang vores hash-tabel er fyldt med 60%, flyttes posterne til en ny hash-tabel med dobbelt størrelse på den oprindelige hash-tabel.
Standardkapacitet og belastningsfaktor
Det er muligt at oprette en samtidig hashmap uden at definere dens kapacitet og belastningsfaktor. For eksempel,
// ConcurrentHashMap with default capacity and load factor ConcurrentHashMap numbers1 = new ConcurrentHashMap();
Som standard,
- kortets kapacitet er 16
- belastningsfaktoren er 0,75
Oprettelse af ConcurrentHashMap fra andre kort
Her er hvordan vi kan oprette en samtidig hashmap, der indeholder alle elementerne i andre kort.
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); ) )
Produktion
HashMap: (Fire = 4, To = 2) Samtidig HashMap: (Fire = 4, To = 2, Tre = 3)
Metoder til ConcurrentHashMap
Den ConcurrentHashMap
klasse indeholder metoder, der tillader os at udføre forskellige operationer på kortet.
Indsæt elementer til ConcurrentHashMap
put()
- indsætter den angivne nøgle- / værdikortlægning på kortetputAll()
- indsætter alle poster fra det angivne kort til dette kortputIfAbsent()
- indsætter den angivne nøgle- / værdikortlægning på kortet, hvis den angivne nøgle ikke er til stede på kortet
For eksempel,
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); ) )
Produktion
ConcurrentHashMap af lige tal: (Six = 6, Four = 4, Two = 2) ConcurrentHashMap of numbers: (Six = 6, One = 1, Four = -4, Two = 2)
Få adgang til ConcurrentHashMap Elements
1. Brug af entrySet (), keySet () og værdier ()
entrySet()
- returnerer et sæt med alle nøgle- / værdikortlæggelser på kortetkeySet()
- returnerer et sæt af alle tasterne på kortetvalues()
- returnerer et sæt af alle kortets værdier
For eksempel,
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()); ) )
Produktion
ConcurrentHashMap: (One = 1, Two = 2, Three = 3) Key / Value mappings: (One = 1, Two = 2, Three = 3) Keys: (One, Two, Three) Værdier: (1, 2, 3 )
2. Brug af get () og getOrDefault ()
get()
- Returnerer den værdi, der er knyttet til den angivne nøgle. Returnerer,null
hvis nøglen ikke findes.getOrDefault()
- Returnerer den værdi, der er knyttet til den angivne nøgle. Returnerer den angivne standardværdi, hvis nøglen ikke findes.
For eksempel,
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); ) )
Produktion
ConcurrentHashMap: (One = 1, Two = 2, Three = 3) Brug af get (): 3 Brug af getOrDefault (): 5
Fjern ConcurrentHashMap Elements
remove(key)
- returnerer og fjerner posten tilknyttet den angivne nøgle fra kortetremove(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?
- Den
ConcurrentHashMap
klasse tillader flere tråde til at få adgang til dens indgange samtidigt. - Som standard er den samtidige hashmap opdelt i 16 segmenter . Dette er grunden til, at 16 tråde får lov til samtidig at ændre kortet på samme tid. Et hvilket som helst antal tråde kan dog få adgang til kortet ad gangen.
- Den
putIfAbsent()
metode vil ikke tilsidesætte posten i kortet, hvis den angivne nøgle findes allerede. - Det giver sin egen synkronisering.