I den här handledningen lär vi oss om klassen Java ConcurrentHashMap och dess funktioner med hjälp av exempel.
Den ConcurrentHashMap
klass av samlingar ramverket Java ger en trådsäker kartan. Det vill säga att flera trådar kan komma åt kartan samtidigt utan att det påverkar konsistensen för poster i en karta.
Det implementerar ConcurrentMap-gränssnittet.
Skapa en ConcurrentHashMap
För att skapa en samtidig hashmap måste vi först importera java.util.concurrent.ConcurrentHashMap
paketet. När vi väl har importerat paketet, här kan vi skapa samtidiga hashmaps i Java.
// ConcurrentHashMap with capacity 8 and load factor 0.6 ConcurrentHashMap numbers = new ConcurrentHashMap(8, 0.6f);
I ovanstående kod har vi skapat en samtidig hashmap med namnen.
Här,
- Nyckel - en unik identifierare som används för att associera varje element (värde) på en karta
- Värde - element som är associerade med nycklar på en karta
Lägg märke till delen new ConcurrentHashMap(8, 0.6)
. Här är den första parametern kapacitet och den andra parametern är loadFactor .
- kapacitet - Kapaciteten på denna karta är 8. Det betyder att den kan lagra 8 poster.
- loadFactor - Lastfaktorn för denna karta är 0,6. Detta innebär att när vår hash-tabell fylls med 60% flyttas posterna till en ny hash-tabell med dubbelt så stor som den ursprungliga hash-tabellen.
Standardkapacitet och lastfaktor
Det är möjligt att skapa en samtidig hashmap utan att definiera dess kapacitet och belastningsfaktor. Till exempel,
// ConcurrentHashMap with default capacity and load factor ConcurrentHashMap numbers1 = new ConcurrentHashMap();
Som standard,
- kartans kapacitet blir 16
- belastningsfaktorn blir 0,75
Skapa ConcurrentHashMap från andra kartor
Här är hur vi kan skapa en samtidig hashmap som innehåller alla element i andra kartor.
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: (Fyra = 4, Två = 2) SamtidigHashMap: (Fyra = 4, Två = 2, Tre = 3)
Metoder för ConcurrentHashMap
I ConcurrentHashMap
klassen innehåller metoder som tillåter oss att utföra olika operationer på kartan.
Infoga element till ConcurrentHashMap
put()
- infogar den angivna nyckel- / värdekartläggningen på kartanputAll()
- infogar alla poster från specificerad karta till denna kartaputIfAbsent()
- infogar den angivna nyckel- / värdekartläggningen på kartan om den angivna nyckeln inte finns på kartan
Till exempel,
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 av jämna siffror: (Sex = 6, Fyra = 4, Två = 2) ConcurrentHashMap av siffror: (Sex = 6, En = 1, Fyra = -4, Två = 2)
Åtkomst till ConcurrentHashMap-element
1. Använda entrySet (), keySet () och värden ()
entrySet()
- returnerar en uppsättning av alla nyckel- / värdekartläggningar på kartankeySet()
- returnerar en uppsättning av alla knappar på kartanvalues()
- returnerar en uppsättning av alla värden på kartan
Till exempel,
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ärden: (1, 2, 3 )
2. Använda get () och getOrDefault ()
get()
- Returnerar värdet som är associerat med den angivna nyckeln. Returnerarnull
om nyckeln inte hittas.getOrDefault()
- Returnerar värdet som är associerat med den angivna nyckeln. Returnerar det angivna standardvärdet om nyckeln inte hittas.
Till exempel,
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: (En = 1, Två = 2, Tre = 3) Använda get (): 3 Använda getOrDefault (): 5
Ta bort ConcurrentHashMap Elements
remove(key)
- returnerar och tar bort posten som är associerad med den angivna nyckeln från kartanremove(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
klass gör att flera trådar för att få tillgång till sina poster samtidigt. - Som standard är den samtidiga hash-kartan uppdelad i 16 segment . Detta är anledningen till att 16 trådar får ändra kartan samtidigt. Valfritt antal trådar kan dock komma åt kartan åt gången.
- Den
putIfAbsent()
metod kommer inte att åsidosätta posten i kartan om den angivna nyckeln redan finns. - Det ger sin egen synkronisering.