Java ConcurrentHashMap

În acest tutorial, vom afla despre clasa Java ConcurrentHashMap și operațiunile sale cu ajutorul unor exemple.

ConcurrentHashMapClasa cadrului colecțiilor Java oferă o hartă thread - safe. Adică, mai multe fire pot accesa harta simultan fără a afecta consistența intrărilor pe hartă.

Implementează interfața ConcurrentMap.

Creați un ConcurrentHashMap

Pentru a crea un hashmap concurent, trebuie mai java.util.concurrent.ConcurrentHashMapîntâi să importăm pachetul. Odată ce am importat pachetul, iată cum putem crea hashmaps simultane în Java.

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

În codul de mai sus, am creat un hashmap simultan numit numere.

Aici,

  • Cheie - un identificator unic utilizat pentru a asocia fiecare element (valoare) pe o hartă
  • Valoare - elemente asociate tastelor dintr-o hartă

Observați partea new ConcurrentHashMap(8, 0.6). Aici, primul parametru este capacitatea, iar al doilea parametru este loadFactor .

  • capacitate - Capacitatea acestei hărți este 8. Adică, poate stoca 8 intrări.
  • loadFactor - Factorul de încărcare al acestei hărți este de 0,6. Aceasta înseamnă că, de fiecare dată când tabelul nostru de hash este umplut cu 60%, intrările sunt mutate într-un nou tabel de hash de două ori mai mare decât tabelul de hash original.

Capacitatea implicită și factorul de încărcare

Este posibil să creați un hashmap simultan fără a-i defini capacitatea și factorul de încărcare. De exemplu,

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

În mod implicit,

  • capacitatea hărții va fi de 16
  • factorul de încărcare va fi 0,75

Crearea ConcurrentHashMap din alte hărți

Iată cum putem crea un hashmap simultan conținând toate elementele altor hărți.

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

Ieșire

 HashMap: (Patru = 4, Două = 2) Concurente HashMap: (Patru = 4, Două = 2, Trei = 3)

Metode ale ConcurrentHashMap

ConcurrentHashMapClasa prevede metode care ne permit de a efectua diverse operații pe hartă.

Inserați elemente în ConcurrentHashMap

  • put() - inserează maparea cheii / valorilor specificate pe hartă
  • putAll() - inserează toate intrările din harta specificată pe această hartă
  • putIfAbsent() - inserează maparea cheii / valorilor specificate pe hartă dacă cheia specificată nu este prezentă pe hartă

De exemplu,

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

Ieșire

 ConcurrentHashMap de numere pare: (Six = 6, Four = 4, Two = 2) ConcurrentHashMap de numere: (Six = 6, One = 1, Four = -4, Two = 2)

Accesați elementele ConcurrentHashMap

1. Utilizarea entrySet (), keySet () și valori ()

  • entrySet() - returns a set of all the key/value mapping of the map
  • keySet() - returns a set of all the keys of the map
  • values() - 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. Returns null 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 map
  • 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?

  • ConcurrentHashMapClasa permite fire multiple pentru a avea acces la intrările sale simultan.
  • În mod implicit, hashmap-ul simultan este împărțit în 16 segmente . Acesta este motivul pentru care 16 fire au dreptul să modifice simultan harta în același timp. Cu toate acestea, orice număr de fire poate accesa harta simultan.
  • putIfAbsent()Metoda nu va suprascrie intrarea în hartă dacă există deja cheia specificată.
  • Oferă propria sincronizare.

Articole interesante...