Java ConcurrentHashMap

Java ConcurrentHashMap

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

ConcurrentHashMap kelas kerangka koleksi Java menyediakan peta thread-safe. 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.ConcurrentHashMap paket dulu. Setelah kita mengimpor paket, berikut adalah bagaimana kita dapat membuat hashmaps bersamaan di Java.

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

Dalam kode di atas, kami telah membuat peta hash bersamaan bernama angka .

Di sini,

• Kunci - pengidentifikasi unik yang digunakan untuk mengaitkan setiap elemen (nilai) dalam peta
• Nilai - elemen yang diasosiasikan dengan kunci di peta

Perhatikan bagian 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

Dimungkinkan untuk membuat peta hash bersamaan tanpa menentukan kapasitas dan faktor bebannya. Misalnya,

// ConcurrentHashMap with default capacity and load factor
ConcurrentHashMap<Key, Value> numbers1 = new ConcurrentHashMap<>();

Secara default,

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

---

Membuat ConcurrentHashMap dari Peta Lain

Berikut adalah bagaimana kita dapat membuat peta hash 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<String, Integer> evenNumbers = new HashMap<>();
        evenNumbers.put("Two", 2);
        evenNumbers.put("Four", 4);
        System.out.println("HashMap: " + evenNumbers);

        // Creating a concurrent hashmap from other map
        ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>(evenNumbers);
        numbers.put("Three", 3);
        System.out.println("ConcurrentHashMap: " + numbers);
    }
}

Keluaran

HashMap: {Four=4, Two=2}
ConcurrentHashMap: {Four=4, Two=2, Three=3}

---

Metode ConcurrentHashMap

ConcurrentHashMap class menyediakan metode yang memungkinkan kita melakukan berbagai operasi pada peta.

---

Sisipkan Elemen ke ConcurrentHashMap

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

Misalnya,

import java.util.concurrent.ConcurrentHashMap;

class Main {
    public static void main(String[] args) {
        // Creating ConcurrentHashMap of even numbers
        ConcurrentHashMap<String, Integer> 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<String, Integer> numbers = new ConcurrentHashMap<>();
        numbers.put("One", 1);

        // Using putAll()
        numbers.putAll(evenNumbers);
        System.out.println("ConcurrentHashMap of numbers: " + numbers);
    }
}

Keluaran

ConcurrentHashMap of even numbers: {Six=6, Four=4, Two=2}
ConcurrentHashMap of numbers: {Six=6, One=1, Four=-4, Two=2}

---

Mengakses Elemen ConcurrentHashMap

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

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

Misalnya,

import java.util.concurrent.ConcurrentHashMap;

class Main {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> 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: {One=1, Two=2, Three=3}
Key/Value mappings: [One=1, Two=2, Three=3]
Keys: [One, Two, Three]
Values: [1, 2, 3]

2. Menggunakan get() dan getOrDefault()

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

Misalnya,

import java.util.concurrent.ConcurrentHashMap;

class Main {
    public static void main(String[] args) {

        ConcurrentHashMap<String, Integer> 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: {One=1, Two=2, Three=3}
Using get(): 3
Using getOrDefault(): 5

---

Hapus Elemen ConcurrentHashMap

• remove(key) - mengembalikan dan menghapus entri yang terkait dengan kunci yang ditentukan dari peta
• remove(key, value) - menghapus entri dari peta hanya jika kunci yang ditentukan dipetakan ke nilai yang ditentukan dan mengembalikan nilai boolean

Misalnya,

import java.util.concurrent.ConcurrentHashMap;

class Main {
    public static void main(String[] args) {

        ConcurrentHashMap<String, Integer> 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);
    }
}

Keluaran

ConcurrentHashMap: {One=1, Two=2, Three=3}
Removed value: 2
Is the entry {Three=3} removed? True
Updated ConcurrentHashMap: {One=1}

---

Operasi Massal ConcurrentHashMap

ConcurrentHashMap class menyediakan operasi massal berbeda yang dapat diterapkan dengan aman ke peta bersamaan.

1. forEach() Metode

forEach() metode mengulangi entri kami dan menjalankan fungsi yang ditentukan.

Ini mencakup dua parameter.

• parallelismThreshold - Ini menentukan bahwa setelah berapa banyak elemen operasi dalam peta dieksekusi secara paralel.
• transformator - Ini akan mengubah data sebelum data diteruskan ke fungsi yang ditentukan.

Misalnya,

import java.util.concurrent.ConcurrentHashMap;

class Main {
    public static void main(String[] args) {

        ConcurrentHashMap<String, Integer> 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 + ", "));
    }
}

Keluaran

ConcurrentHashMap: {One = 1, Two = 2, Three = 3}
key: One value: 1
key: Two value: 2
key: Three value: 3
Values are 1, 2, 3,

Dalam program di atas, kami telah menggunakan ambang paralel 4 . Ini berarti jika peta berisi 4 entri, operasi akan dijalankan secara paralel.

Variasi Metode forEach()

• forEachEntry() - menjalankan fungsi yang ditentukan untuk setiap entri
• forEachKey() - menjalankan fungsi yang ditentukan untuk setiap tombol
• forEachValue() - mengeksekusi fungsi yang ditentukan untuk setiap nilai

---

2. search() Metode

search() metode mencari peta berdasarkan fungsi yang ditentukan dan mengembalikan entri yang cocok.

Di sini, fungsi yang ditentukan menentukan entri apa yang akan dicari.

Ini juga menyertakan parameter opsional parallelThreshold . Ambang batas paralel menentukan bahwa setelah berapa banyak elemen dalam peta, operasi dijalankan secara paralel.

Misalnya,

import java.util.concurrent.ConcurrentHashMap;

class Main {
    public static void main(String[] args) {

        ConcurrentHashMap<String, Integer> 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);

    }
}

Keluaran

ConcurrentHashMap: {One=1, Two=2, Three=3}
Searched value: Three

Varian Metode search()

• searchEntries() - fungsi pencarian diterapkan pada pemetaan kunci/nilai
• searchKeys() - fungsi pencarian hanya diterapkan pada tombol
• searchValues() - fungsi pencarian hanya diterapkan pada nilai

---

3. kurangi() Metode

reduce() metode mengumpulkan (mengumpulkan bersama) setiap entri dalam peta. Ini dapat digunakan saat kita membutuhkan semua entri untuk melakukan tugas umum, seperti menambahkan semua nilai peta.

Ini mencakup dua parameter.

• parallelismThreshold - Ini menentukan bahwa setelah berapa banyak elemen, operasi dalam peta dijalankan secara paralel.
• transformator - Ini akan mengubah data sebelum data diteruskan ke fungsi yang ditentukan.

Misalnya,

import java.util.concurrent.ConcurrentHashMap;

class Main {
    public static void main(String[] args) {

        ConcurrentHashMap<String, Integer> 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);

    }
}

Keluaran

ConcurrentHashMap: {One=1, Two=2, Three=3}
Sum of all values: 6

Pada program di atas, perhatikan pernyataan

numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1+v2);

Di sini,

• 4 adalah ambang paralel
• (k, v) -> v adalah fungsi transformator. Ini mentransfer pemetaan kunci/nilai menjadi nilai saja.
• (v1, v2) -> v1+v2 adalah fungsi peredam. Ini mengumpulkan semua nilai dan menambahkan semua nilai.

Varian Metode reduce()

• reduceEntries() - mengembalikan hasil pengumpulan semua entri menggunakan fungsi peredam yang ditentukan
• reduceKeys() - mengembalikan hasil pengumpulan semua kunci menggunakan fungsi peredam yang ditentukan
• reduceValues() - mengembalikan hasil pengumpulan semua nilai menggunakan fungsi peredam yang ditentukan

---

ConcurrentHashMap vs HashMap

Berikut adalah beberapa perbedaan antara ConcurrentHashMap dan HashMap,

• ConcurrentHashMap adalah aman untuk thread koleksi. Artinya, beberapa utas dapat mengakses dan memodifikasinya secara bersamaan.
• ConcurrentHashMap menyediakan metode untuk operasi massal seperti forEach() , search() dan reduce() .

---

Mengapa ConcurrentHashMap?

• ConcurrentHashMap class memungkinkan beberapa utas untuk mengakses entrinya secara bersamaan.
• Secara default, peta hash bersamaan dibagi menjadi 16 segmen . Inilah alasan mengapa 16 utas diizinkan untuk mengubah peta secara bersamaan pada saat yang bersamaan. Namun, sejumlah utas dapat mengakses peta sekaligus.
• putIfAbsent() metode tidak akan menimpa entri di peta jika kunci yang ditentukan sudah ada.
• Ini menyediakan sinkronisasinya sendiri.