Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

ConcurrentHashMap: get, put e merge atomico

Usa `get` per leggere, `put` per scrivere senza condizioni e `merge` per aggiornare una sola chiave in modo atomico, ad esempio in un contatore condiviso tra thread.

Versione: Java SE 21

Sintassi

import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiFunction;

// Instance methods of ConcurrentHashMap<K, V>
public V get(Object key)
public V put(K key, V value)
public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)

In Java SE 21, ConcurrentHashMap.get (get(Object key)) legge un valore senza modificare la mappa e restituisce null se la chiave è assente. ConcurrentHashMap.put inserisce o sostituisce un valore e restituisce il valore precedente, oppure null se non c’era alcuna voce.

Se la chiave è assente, ConcurrentHashMap.merge inserisce il valore fornito senza chiamare la funzione. Se la chiave è presente, passa alla funzione prima il valore esistente e poi quello fornito. Salva e restituisce il risultato, oppure rimuove la voce e restituisce null se la funzione restituisce null.

La mappa non ammette chiavi o valori null. Una chiave null in uno di questi metodi, un valore null passato a put o merge o una funzione null passata a merge provoca una NullPointerException. Se la funzione lancia una RuntimeException o un Error, merge la propaga senza modificare la voce. Mantieni breve la funzione: alcuni aggiornamenti potrebbero dover attendere che termini. La funzione non deve modificare questa mappa durante il calcolo. Se merge rileva un tentativo di aggiornamento ricorsivo di questa mappa che altrimenti non terminerebbe mai, lancia una IllegalStateException.

Una chiamata a merge legge e aggiorna atomicamente la voce di una sola chiave. Chiamate separate a get e put possono perdere un incremento se due thread leggono lo stesso valore e scrivono lo stesso risultato. Questa garanzia è propria di ConcurrentHashMap, non dell’implementazione predefinita di Map.merge, e non offre una transazione su più chiavi.

Esempi

import java.util.concurrent.ConcurrentHashMap;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        var counts = new ConcurrentHashMap<String, Integer>();
        String key = "hits";

        System.out.println(counts.get(key));
        System.out.println(counts.merge(key, 1, Integer::sum));
        System.out.println(counts.put(key, 10));

        Runnable increment = () -> {
            for (int i = 0; i < 1_000; i++) {
                counts.merge(key, 1, Integer::sum);
            }
        };
        Thread first = new Thread(increment);
        Thread second = new Thread(increment);
        first.start();
        second.start();
        first.join();
        second.join();

        System.out.println(counts.get(key));
        System.out.println(counts.merge(key, 1, (oldValue, addedValue) -> null));
        System.out.println(counts.get(key));
    }
}

Risultato

null
1
1
2010
null
null

La prima lettura restituisce `null`. Il primo `merge` inserisce e restituisce `1`, mentre `put` salva `10` e restituisce il precedente `1`. Ogni thread aggiunge 1000; `join()` attende che entrambi terminino prima di leggere `2010`. L’ultimo `merge` rimuove la voce: sia la chiamata sia la lettura successiva restituiscono `null`.

Lezioni correlate

  • Java · Lezione 56 · Intermedio · Versione: 2

Fonti