Java ConcurrentHashMap

Dalam tutorial ini, kita akan belajar tentang kelas Java ConcurrentHashMap dan operasinya dengan bantuan contoh.

The ConcurrentHashMapkelas dari koleksi kerangka Java menyediakan peta benang-aman. Artinya, beberapa utas dapat mengakses peta sekaligus tanpa memengaruhi konsistensi entri dalam peta.

Ini mengimplementasikan antarmuka ConcurrentMap.

Buat ConcurrentHashMap

Untuk membuat hashmap bersamaan, kita harus mengimpor java.util.concurrent.ConcurrentHashMappaket terlebih dahulu. Setelah kami mengimpor paket, berikut adalah cara membuat hashmaps bersamaan di Java.

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

Pada kode di atas, kami telah membuat hashmap bersamaan bernama angka.

Sini,

  • Kunci - pengenal unik yang digunakan untuk mengaitkan setiap elemen (nilai) di peta
  • Nilai - elemen yang terkait dengan kunci di peta

Perhatikan bagiannya new ConcurrentHashMap(8, 0.6). Di sini, parameter pertama adalah kapasitas dan parameter kedua adalah loadFactor .

  • kapasitas - Kapasitas peta ini adalah 8. Artinya, dapat menyimpan 8 entri.
  • loadFactor - Faktor beban peta ini adalah 0,6. Ini berarti, setiap kali tabel hash kita terisi 60%, entri akan dipindahkan ke tabel hash baru dengan ukuran dua kali lipat dari tabel hash asli.

Kapasitas default dan faktor beban

Anda dapat membuat hashmap bersamaan tanpa menentukan kapasitas dan faktor muatnya. Sebagai contoh,

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

Secara default,

  • kapasitas peta akan menjadi 16
  • faktor beban akan menjadi 0,75

Membuat ConcurrentHashMap dari Peta Lain

Inilah cara kita membuat hashmap bersamaan yang berisi semua elemen peta lainnya.

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

Keluaran

 HashMap: (Empat = 4, Dua = 2) ConcurrentHashMap: (Empat = 4, Dua = 2, Tiga = 3)

Metode ConcurrentHashMap

The ConcurrentHashMapkelas menyediakan metode yang memungkinkan kita untuk melakukan berbagai operasi pada peta.

Sisipkan Elemen ke ConcurrentHashMap

  • put() - menyisipkan pemetaan kunci / nilai yang ditentukan ke peta
  • putAll() - memasukkan semua entri dari peta tertentu ke peta ini
  • putIfAbsent() - menyisipkan pemetaan kunci / nilai yang ditentukan ke peta jika kunci yang ditentukan tidak ada di peta

Sebagai contoh,

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

Keluaran

 ConcurrentHashMap bilangan genap: (Enam = 6, Empat = 4, Dua = 2) Bilangan ConcurrentHashMap: (Enam = 6, Satu = 1, Empat = -4, Dua = 2)

Akses Elemen ConcurrentHashMap

1. Menggunakan entrySet (), keySet () dan nilai ()

  • entrySet() - mengembalikan satu set dari semua pemetaan kunci / nilai peta
  • keySet() - mengembalikan satu set semua kunci peta
  • values() - mengembalikan satu set semua nilai peta

Sebagai contoh,

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

Keluaran

 ConcurrentHashMap: (Satu = 1, Dua = 2, Tiga = 3) Pemetaan Kunci / Nilai: (Satu = 1, Dua = 2, Tiga = 3) Kunci: (Satu, Dua, Tiga) Nilai: (1, 2, 3 )

2. Menggunakan get () dan getOrDefault ()

  • get()- Mengembalikan nilai yang terkait dengan kunci yang ditentukan. Mengembalikan nulljika kunci tidak ditemukan.
  • getOrDefault()- Mengembalikan nilai yang terkait dengan kunci yang ditentukan. Mengembalikan nilai default yang ditentukan jika kunci tidak ditemukan.

Sebagai contoh,

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

Keluaran

 ConcurrentHashMap: (Satu = 1, Dua = 2, Tiga = 3) Menggunakan get (): 3 Menggunakan getOrDefault (): 5

Hapus Elemen ConcurrentHashMap

  • remove(key) - mengembalikan dan menghapus entri yang terkait dengan kunci tertentu dari peta
  • 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?

  • The ConcurrentHashMapkelas memungkinkan beberapa thread untuk mengakses entri yang bersamaan.
  • Secara default, hashmap serentak dibagi menjadi 16 segmen . Inilah alasan mengapa 16 thread diizinkan untuk mengubah peta secara bersamaan pada waktu yang bersamaan. Namun, sejumlah utas dapat mengakses peta dalam satu waktu.
  • The putIfAbsent()Metode tidak akan menimpa masuk dalam peta jika kunci tertentu sudah ada.
  • Ini menyediakan sinkronisasi sendiri.

Artikel yang menarik...