KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

ConcurrentHashMap: tellers atomair initialiseren en sleutel-waardeparen doorlopen

Gebruik `computeIfAbsent` om voor een ontbrekende sleutel atomair een `LongAdder` te maken en `forEach` om tellingen uit te lezen zonder te vertrouwen op de volgorde.

Versie: Java SE 21

Syntax

V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
void forEach(BiConsumer<? super K, ? super V> action)
void forEach(long parallelismThreshold, BiConsumer<? super K, ? super V> action)
<U> void forEach(long parallelismThreshold, BiFunction<? super K, ? super V, ? extends U> transformer, Consumer<? super U> action)

In Java SE 21 geeft computeIfAbsent(key, factory) van java.util.concurrent.ConcurrentHashMap atomair de bestaande waarde terug zonder de functie aan te roepen. Ontbreekt de sleutel, dan roept de methode de functie één keer per aanroep aan, slaat een resultaat anders dan null op en geeft het terug. De standaardimplementatie van Map.computeIfAbsent garandeert geen synchronisatie of atomiciteit. Ook via een Map-referentie naar een ConcurrentHashMap wordt de overschreven methode van de klasse gebruikt.

De map accepteert geen null als sleutel of waarde. Een sleutel of functie die null is, leidt tot NullPointerException; geeft de functie null terug, dan geeft de methode null terug zonder een item aan te maken. Een RuntimeException of Error uit de functie wordt doorgegeven zonder een item aan te maken. Houd de functie kort en wijzig daarin niet dezelfde map: andere updates moeten mogelijk wachten, en een gedetecteerde recursieve update die anders nooit zou eindigen leidt tot IllegalStateException.

In counts.computeIfAbsent(word, k -> new LongAdder()).increment() begint de teller uit java.util.concurrent.atomic op nul. De threadveilige increment() volgt op de mapbewerking en valt niet binnen dezelfde atomaire bewerking. Als een andere thread het item verwijdert of vervangt, kan de verhoging een teller treffen die niet meer in de map staat. sum() is exact zolang de teller niet gelijktijdig wordt bijgewerkt, maar is geen atomaire momentopname.

forEach(action) geeft sleutel en waarde sequentieel door aan de actie, zonder drempel. forEach(threshold, action) kan afhankelijk van de geschatte grootte van de map ForkJoinPool.commonPool() gebruiken: Long.MAX_VALUE schakelt parallelle uitvoering uit en 1 bevordert maximaal parallellisme. Een parallelle actie moet veilig omgaan met gedeelde toestand. forEach(threshold, transformer, action) geeft alleen transformatieresultaten anders dan null aan de actie door. Geen overload garandeert een volgorde of een atomaire momentopname van de hele map tijdens updates.

Voorbeelden

import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.LongAdder;

public class WordCounts {
    private static void count(ConcurrentHashMap<String, LongAdder> counts,
                              String... words) {
        for (String word : words) {
            counts.computeIfAbsent(word, k -> new LongAdder()).increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        var counts = new ConcurrentHashMap<String, LongAdder>();
        var first = new Thread(() -> count(counts, "pear", "apple", "pear"));
        var second = new Thread(() -> count(counts, "apple", "plum"));
        first.start();
        second.start();
        first.join();
        second.join();

        var sorted = new TreeMap<String, Long>();
        counts.forEach(Long.MAX_VALUE, (word, counter) -> sorted.put(word, counter.sum()));
        sorted.forEach((word, total) -> System.out.println(word + "=" + total));
    }
}

Resultaat

apple=2
pear=2
plum=1

Na beide `join()`-aanroepen veranderen de tellers niet meer. `Long.MAX_VALUE` houdt de schrijfbewerkingen naar de `TreeMap` sequentieel; de `TreeMap` sorteert de uitvoer op sleutel.

Gerelateerde lessen

  • Java · Les 24 · Gevorderd · Versie: 2

Bronnen