Java vienlaicīgiHashMap

Šajā apmācībā mēs ar piemēru palīdzību uzzināsim par Java ConcurrentHashMap klasi un tās darbībām.

ConcurrentHashMapJava kolekcijas ietvaros klase nodrošina pavedienu drošu karti. Tas ir, vairāki pavedieni var piekļūt kartei vienlaikus, neietekmējot ierakstu konsekvenci kartē.

Tas ievieš saskarni ConcurrentMap.

Izveidojiet ConcurrentHashMap

Lai izveidotu vienlaicīgu hashmap, mums vispirms ir jāimportē java.util.concurrent.ConcurrentHashMappakete. Kad pakotne ir importēta, šeit ir redzams, kā Java var izveidot vienlaicīgas hashmaps.

 // ConcurrentHashMap with capacity 8 and load factor 0.6 ConcurrentHashMap numbers = new ConcurrentHashMap(8, 0.6f);

Iepriekš minētajā kodā mēs esam izveidojuši vienlaicīgus hashmap nosauktos numurus.

Šeit,

  • Atslēga - unikāls identifikators, ko izmanto, lai katru elementu (vērtību) saistītu kartē
  • Vērtība - elementi, kas saistīti ar atslēgām kartē

Ievērojiet daļu new ConcurrentHashMap(8, 0.6). Pirmais parametrs ir kapacitāte, bet otrais parametrs - loadFactor .

  • ietilpība - šīs kartes ietilpība ir 8. Tas nozīmē, ka tajā var saglabāt 8 ierakstus.
  • loadFactor - šīs kartes slodzes koeficients ir 0,6. Tas nozīmē, ka ikreiz, kad mūsu jaukšanas tabula ir aizpildīta par 60%, ieraksti tiek pārvietoti uz jaunu jaukšanas tabulu, kas ir divreiz lielāka par sākotnējās jaukšanas tabulas lielumu.

Noklusējuma jauda un slodzes koeficients

Ir iespējams izveidot vienlaicīgu hashmap, nenosakot tā jaudu un slodzes koeficientu. Piemēram,

 // ConcurrentHashMap with default capacity and load factor ConcurrentHashMap numbers1 = new ConcurrentHashMap();

Pēc noklusējuma,

  • kartes ietilpība būs 16 vietas
  • slodzes koeficients būs 0,75

ConcurrentHashMap izveide no citām kartēm

Lūk, kā mēs varam izveidot vienlaicīgu hashmap, kas satur visus citu karšu elementus.

 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); ) )

Rezultāts

 HashMap: (četri = 4, divi = 2) VienlaicīgiHashMap: (četri = 4, divi = 2, trīs = 3)

ConcurrentHashMap metodes

ConcurrentHashMapKlase nodrošina metodes, kas ļauj mums, lai veiktu dažādas darbības kartē.

Ievietojiet elementus ConcurrentHashMap

  • put() - ievieto kartē norādīto atslēgu / vērtību kartēšanu
  • putAll() - ievieto šajā kartē visus ierakstus no norādītās kartes
  • putIfAbsent() - ievieto kartē norādīto atslēgu / vērtību kartēšanu, ja norādītās atslēgas kartē nav

Piemēram,

 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); ) )

Rezultāts

 Pāra skaitļu vienlaicīga hash karte: (seši = 6, četri = 4, divi = 2) vienlaicīgi skaitļi: (seši = 6, viens = 1, četri = -4, divi = 2)

Piekļūstiet ConcurrentHashMap elementiem

1. Izmantojot entrySet (), keySet () un vērtības ()

  • entrySet() - atgriež visu kartes atslēgu / vērtību kartēšanas kopu
  • keySet() - atgriež visu kartes taustiņu kopu
  • values() - atgriež visu kartes vērtību kopu

Piemēram,

 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()); ) )

Rezultāts

 ConcurrentHashMap: (viens = 1, divi = 2, trīs = 3) atslēgu / vērtību kartējumi: (viens = 1, divi = 2, trīs = 3) taustiņi: (viens, divi, trīs) vērtības: (1, 2, 3 )

2. get () un getOrDefault () izmantošana

  • get()- atgriež vērtību, kas saistīta ar norādīto atslēgu. Atgriež, nullja atslēga nav atrasta.
  • getOrDefault()- atgriež vērtību, kas saistīta ar norādīto atslēgu. Atgriež norādīto noklusējuma vērtību, ja atslēga nav atrasta.

Piemēram,

 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); ) )

Rezultāts

 ConcurrentHashMap: (Viens = 1, Divi = 2, Trīs = 3) Izmantojot get (): 3 Izmantojot getOrDefault (): 5

Noņemiet ConcurrentHashMap elementus

  • remove(key) - atgriež un noņem no kartes ar norādīto atslēgu saistīto ierakstu
  • remove(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 entry
  • forEachKey() - executes the specified function for each key
  • forEachValue() - 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 mappings
  • searchKeys() - search function is only applied to the keys
  • searchValues() - 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 function
  • reduceKeys() - returns the result of gathering all the keys using the specified reducer function
  • reduceValues() - 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 like forEach(), search() and reduce().

Why ConcurrentHashMap?

  • ConcurrentHashMapKlase ļauj vairākus pavedienus, lai piekļūtu saviem ierakstus vienlaicīgi.
  • Pēc noklusējuma vienlaicīgais hashmap ir sadalīts 16 segmentos . Šī iemesla dēļ 16 pavedieniem ir atļauts vienlaikus modificēt karti. Tomēr kartei vienlaikus var piekļūt jebkurš pavedienu skaits.
  • putIfAbsent()Metode nebūs ignorēt ierakstu kartē, ja norādītā atslēga jau pastāv.
  • Tas nodrošina savu sinhronizāciju.

Interesanti raksti...