Java ConcurrentHashMap

Verken de Java ConcurrentHashMap-klasse, leer hoe je deze kunt aanmaken en manipuleren, en ontdek de belangrijkste voordelen met praktische codevoorbeelden.

De ConcurrentHashMap-klasse uit het Java collections framework biedt een thread-veilige map-implementatie. Meerdere threads kunnen gelijktijdig lezen en schrijven zonder de integriteit van de map te schenden.

Het implementeert de ConcurrentMap-interface en is onderdeel van java.util.concurrent.

Een ConcurrentHashMap aanmaken

Eerst de klasse importeren:

import java.util.concurrent.ConcurrentHashMap;

Instantieer het. Je kunt een initiële capaciteit en load factor specificeren, of vertrouwen op de standaarden.

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

Parameters

• capaciteit – het initiële aantal buckets (8 in het voorbeeld).
• loadFactor – triggert een resize wanneer de map 60% vol is.

Standaard constructor creëert een map met capaciteit 16 en load factor 0.75:

ConcurrentHashMap<Key, Value> numbers1 = new ConcurrentHashMap<>();

ConcurrentHashMap aanmaken vanuit bestaande Maps

Je kunt een nieuwe ConcurrentHashMap vullen met de entries van een willekeurige andere map.

import java.util.concurrent.ConcurrentHashMap; import java.util.HashMap; class Main { public static void main(String[] args) { HashMap<String, Integer> evenNumbers = new HashMap<>(); evenNumbers.put("Two", 2); evenNumbers.put("Four", 4); System.out.println("HashMap: " + evenNumbers); ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>(evenNumbers); numbers.put("Three", 3); System.out.println("ConcurrentHashMap: " + numbers); } }

Output

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

Belangrijkste methoden van ConcurrentHashMap

Elementen invoegen

• put(K key, V value) – Voegt of vervangt een mapping.
• putAll(Map<? extends K, ? extends V> m) – Bulk invoeging.
• putIfAbsent(K key, V value) – Voegt alleen toe als key afwezig is.

ConcurrentHashMap<String, Integer> evenNumbers = new ConcurrentHashMap<>(); evenNumbers.put("Two", 2); evenNumbers.put("Four", 4); evenNumbers.putIfAbsent("Six", 6); System.out.println("Even numbers: " + evenNumbers); ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>(); numbers.put("One", 1); numbers.putAll(evenNumbers); System.out.println("Numbers: " + numbers);

Output

Even numbers: {Six=6, Four=4, Two=2} Numbers: {Six=6, One=1, Four=4, Two=2}

Elementen benaderen

Gebruik view-collecties of key/value-ophalingsmethoden.

• entrySet(), keySet(), values() – Retourneert collecties van entries, keys of values.
• get(K key) – Haalt een waarde op of null als afwezig.
• getOrDefault(K key, V defaultValue) – Haalt een waarde op of een meegeleverde default.

ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); System.out.println("Map: " + numbers); System.out.println("Entries: " + numbers.entrySet()); System.out.println("Keys: " + numbers.keySet()); System.out.println("Values: " + numbers.values()); int val = numbers.get("Three"); System.out.println("get(\"Three\"): " + val); int def = numbers.getOrDefault("Five", 5); System.out.println("getOrDefault(\"Five\", 5): " + def);

Output

Map: {One=1, Two=2, Three=3} Entries: [One=1, Two=2, Three=3] Keys: [One, Two, Three] Values: [1, 2, 3] get("Three"): 3 getOrDefault("Five", 5): 5

Entries verwijderen

• remove(K key) – Verwijdert de mapping en retourneert de waarde.
• remove(K key, V value) – Verwijdert alleen als de huidige waarde matcht; retourneert boolean.

ConcurrentHashMap<String, Integer> numbers = new ConcurrentHashMap<>(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); int removed = numbers.remove("Two"); System.out.println("Verwijderde waarde: " + removed); boolean deleted = numbers.remove("Three", 3); System.out.println("Entry {Three=3} verwijderd? " + deleted); System.out.println("Bijgewerkte map: " + numbers);

Output

Verwijderde waarde: 2 Entry {Three=3} verwijderd? true Bijgewerkte map: {One=1}

Bulk-operaties

Deze methoden benutten parallelisme om grote maps efficiënt te verwerken.

forEach()

Itereert over entries, optioneel parallel, en past een consumer toe.

numbers.forEach(4, (k, v) -> System.out.println("key: " + k + " value: " + v)); // Met transformer: numbers.forEach(4, (k, v) -> v, (v) -> System.out.print(v + ", "));

Hier is 4 de parallel threshold – wanneer de map minstens 4 elementen heeft, kan de operatie concurrent draaien.

search()

Zoekt een entry die voldoet aan een predicate. Retourneert de eerste match.

String key = numbers.search(4, (k, v) -> v == 3 ? k : null); System.out.println("Gezochte key: " + key);

reduce()

Aggregateert waarden met een reducer. Nuttig voor sommen, producten of custom accumulaties.

int sum = numbers.reduce(4, (k, v) -> v, (v1, v2) -> v1 + v2); System.out.println("Som van waarden: " + sum);

ConcurrentHashMap vs. HashMap

• Thread-veiligheid – ConcurrentHashMap staat veilige concurrente modificaties toe; HashMap is niet thread-veilig.
• Bulk-methoden – ConcurrentHashMap biedt forEach, search en reduce voor parallelle verwerking.

Waarom ConcurrentHashMap gebruiken?

• Ondersteunt hoge concurrency met minimale blocking.
• Intern verdeeld in 16 segmenten, wat tot 16 threads toestaat om verschillende segmenten gelijktijdig te wijzigen.
• Operaties zoals putIfAbsent voorkomen accidentele overschrijvingen.
• Ingebouwde synchronisatie elimineert de noodzaak voor externe locks.