I denne veiledningen vil vi lære om Java ConcurrentHashMap-klassen og dens operasjoner ved hjelp av eksempler.
Den ConcurrentHashMap
klassen av Java samlinger rammeverket gir en tråd-safe kartet. Det vil si at flere tråder kan få tilgang til kartet samtidig uten å påvirke konsistensen til oppføringene på et kart.
Den implementerer ConcurrentMap-grensesnittet.
Opprett et ConcurrentHashMap
For å opprette en samtidig hashmap, må vi først importere java.util.concurrent.ConcurrentHashMap
pakken. Når vi først har importert pakken, kan du lage samtidige hashmaps i Java.
// ConcurrentHashMap with capacity 8 and load factor 0.6 ConcurrentHashMap numbers = new ConcurrentHashMap(8, 0.6f);
I koden ovenfor har vi opprettet en samtidig hashmap med navn.
Her,
- Nøkkel - en unik identifikator som brukes til å knytte hvert element (verdi) til et kart
- Verdi - elementer tilknyttet nøkler i et kart
Legg merke til delen new ConcurrentHashMap(8, 0.6)
. Her er den første parameteren kapasitet og den andre parameteren loadFactor .
- kapasitet - Kapasiteten til dette kartet er 8. Det betyr at det kan lagre 8 oppføringer.
- loadFactor - Lastfaktoren på dette kartet er 0,6. Dette betyr at når hash-tabellen vår fylles med 60%, flyttes oppføringene til en ny hash-tabell med dobbel størrelse på den opprinnelige hash-tabellen.
Standard kapasitet og lastfaktor
Det er mulig å lage en samtidig hashmap uten å definere kapasitet og belastningsfaktor. For eksempel,
// ConcurrentHashMap with default capacity and load factor ConcurrentHashMap numbers1 = new ConcurrentHashMap();
Som standard
- kapasiteten til kartet vil være 16
- lastfaktoren vil være 0,75
Opprette ConcurrentHashMap fra andre kart
Slik kan vi lage en samtidig hashmap som inneholder alle elementene i andre kart.
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); ) )
Produksjon
HashMap: (Fire = 4, To = 2) Samtidig HashKart: (Fire = 4, To = 2, Tre = 3)
Metoder for ConcurrentHashMap
Den ConcurrentHashMap
klassen inneholder metoder som tillater oss å utføre ulike operasjoner på kartet.
Sett inn elementer i ConcurrentHashMap
put()
- setter inn den spesifiserte nøkkel- / verdikartleggingen på kartetputAll()
- setter inn alle oppføringene fra spesifisert kart til dette kartetputIfAbsent()
- setter inn den angitte nøkkel- / verdikartleggingen på kartet hvis den angitte nøkkelen ikke er til stede på kartet
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); ) )
Produksjon
ConcurrentHashMap of even numbers: (Six = 6, Four = 4, Two = 2) ConcurrentHashMap of numbers: (Six = 6, One = 1, Four = -4, Two = 2)
Få tilgang til ConcurrentHashMap Elements
1. Bruke entrySet (), keySet () og verdier ()
entrySet()
- returnerer et sett med all nøkkel- / verdikartlegging av kartetkeySet()
- returnerer et sett med alle tastene på kartetvalues()
- returnerer et sett med alle verdiene på kartet
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()); ) )
Produksjon
ConcurrentHashMap: (One = 1, Two = 2, Three = 3) Key / Value mappings: (One = 1, Two = 2, Three = 3) Keys: (One, Two, Three) Verdier: (1, 2, 3 )
2. Bruke get () og getOrDefault ()
get()
- Returnerer verdien som er knyttet til den angitte nøkkelen. Returnerernull
hvis nøkkelen ikke blir funnet.getOrDefault()
- Returnerer verdien som er knyttet til den angitte nøkkelen. Returnerer den angitte standardverdien hvis nøkkelen ikke blir funnet.
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); ) )
Produksjon
ConcurrentHashMap: (One = 1, Two = 2, Three = 3) Bruke get (): 3 Bruke getOrDefault (): 5
Fjern ConcurrentHashMap Elements
remove(key)
- returnerer og fjerner oppføringen tilknyttet den angitte nøkkelen fra kartetremove(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 kan flere tråder for å få tilgang til oppføringene samtidig. - Som standard er samtidig hashmap delt inn i 16 segmenter . Dette er grunnen til at 16 tråder får lov til å endre kartet samtidig. Et hvilket som helst antall tråder kan imidlertid få tilgang til kartet om gangen.
- Den
putIfAbsent()
metoden vil ikke overstyre oppføring i kartet hvis den angitte nøkkelen allerede eksisterer. - Det gir sin egen synkronisering.