Tässä opetusohjelmassa opitaan Java ConcurrentHashMap -luokasta ja sen toiminnoista esimerkkien avulla.
ConcurrentHashMap
Luokka Java kokoelmien kehys tarjoaa säieturvallinen kartalla. Toisin sanoen useat ketjut voivat käyttää karttaa kerralla vaikuttamatta kartalla olevien merkintöjen yhdenmukaisuuteen.
Se toteuttaa ConcurrentMap-käyttöliittymän.
Luo ConcurrentHashMap
Jotta voimme luoda samanaikaisen hashmapin, meidän on java.util.concurrent.ConcurrentHashMap
ensin tuotava paketti. Kun paketti on tuotu, voimme näin luoda samanaikaisia hashappeja Java-sovellukseen.
// ConcurrentHashMap with capacity 8 and load factor 0.6 ConcurrentHashMap numbers = new ConcurrentHashMap(8, 0.6f);
Yllä olevassa koodissa olemme luoneet samanaikaiset hashmap-nimetyt numerot.
Tässä,
- Avain - yksilöllinen tunniste, jota käytetään kunkin elementin (arvon) liittämiseen karttaan
- Arvo - elementit, jotka on liitetty avaimiin kartalla
Huomaa osa new ConcurrentHashMap(8, 0.6)
. Ensimmäinen parametri on kapasiteetti ja toinen parametri loadFactor .
- kapasiteetti - Tämän kartan kapasiteetti on 8. Tämä tarkoittaa, että se voi tallentaa 8 merkintää.
- loadFactor - Tämän kartan kuormituskerroin on 0,6. Tämä tarkoittaa, että aina kun hash-taulukkoamme täytetään 60%, merkinnät siirretään uuteen hash-taulukkoon, joka on kaksinkertainen alkuperäisen hash-taulukon kokoon nähden.
Oletuskapasiteetti ja kuormituskerroin
On mahdollista luoda samanaikainen hashmap määrittelemättä sen kapasiteettia ja kuormituskerrointa. Esimerkiksi,
// ConcurrentHashMap with default capacity and load factor ConcurrentHashMap numbers1 = new ConcurrentHashMap();
Oletuksena,
- kartan kapasiteetti on 16
- kuormituskerroin on 0,75
ConcurrentHashMapin luominen muista kartoista
Näin voimme luoda samanaikaisen hashapin, joka sisältää kaikki muiden karttojen elementit.
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); ) )
Tuotos
HashMap: (Neljä = 4, Kaksi = 2) SamanaikainenHashMap: (Neljä = 4, Kaksi = 2, Kolme = 3)
Menetelmät ConcurrentHashMap
ConcurrentHashMap
Luokan tarjoaa menetelmiä, joiden avulla voimme suorittaa erilaisia toimenpiteitä kartalle.
Lisää elementit ConcurrentHashMapiin
put()
- lisää määritetyn avaimen / arvon kartoituksen kartalleputAll()
- lisää kaikki määritetyn kartan merkinnät tähän karttaanputIfAbsent()
- lisää määritetyn avaimen / arvon kartoituksen, jos määritettyä avainta ei ole kartalla
Esimerkiksi,
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); ) )
Tuotos
Parillisten numeroiden yhtäkertainen hash-kartta: (kuusi = 6, neljä = 4, kaksi = 2)
Käytä ConcurrentHashMap-elementtejä
1. Käyttämällä entrySet (), keySet () ja arvoja ()
entrySet()
- returns a set of all the key/value mapping of the mapkeySet()
- returns a set of all the keys of the mapvalues()
- returns a set of all the values of the map
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 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()); ) )
Output
ConcurrentHashMap: (One=1, Two=2, Three=3) Key/Value mappings: (One=1, Two=2, Three=3) Keys: (One, Two, Three) Values: (1, 2, 3)
2. Using get() and getOrDefault()
get()
- Returns the value associated with the specified key. Returnsnull
if the key is not found.getOrDefault()
- Returns the value associated with the specified key. Returns the specified default value if the key is not found.
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 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); ) )
Output
ConcurrentHashMap: (One=1, Two=2, Three=3) Using get(): 3 Using getOrDefault(): 5
Remove ConcurrentHashMap Elements
remove(key)
- returns and removes the entry associated with the specified key from the mapremove(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?
ConcurrentHashMap
Luokan avulla useita säikeitä käyttää sen merkinnät samanaikaisesti.- Oletuksena samanaikainen hashmap on jaettu 16 segmenttiin . Tämä on syy, miksi 16 säiettä saa samanaikaisesti muokata karttaa samanaikaisesti. Kuitenkin mikä tahansa määrä ketjuja voi käyttää karttaa kerrallaan.
putIfAbsent()
Menetelmä ei korvaa merkintä kartassa jos määritetty avain on jo olemassa.- Se tarjoaa oman synkronoinnin.