ConcurrentHashMap in Java?

Question

Qual è l'uso di ConcurrentHashMap in Java? Quali sono i suoi vantaggi? Come funziona? Codice di esempio sarebbe utile anche.

Answer 1

Il punto è quello di fornire un'implementazione di HashMap che è threadsafe. Più thread possono leggere e scrivere senza la possibilità di ricevere out-of-data o dati corrotti. ConcurrentHashMap fornisce la propria sincronizzazione, quindi non c'è bisogno di sincronizzare gli accessi ad essa in modo esplicito.

Un'altra caratteristica di ConcurrentHashMap è che fornisce il metodo putIfAbsent, che sarà atomicamente aggiungere una mappatura se la chiave specificata non esiste. Si consideri il seguente codice:

ConcurrentHashMap<String, Integer> myMap = new ConcurrentHashMap<String, Integer>();

// some stuff

if (!myMap.contains("key")) {
  myMap.put("key", 3);
}

Questo codice non è threadsafe, perché un altro thread potrebbe aggiungere una mappatura per "key" tra la chiamata al contains e la chiamata a put. La corretta attuazione potrebbe essere:

myMap.putIfAbsent("key", 3);

Answer 2

ConcurrentHashMap consentire l'accesso simultaneo alla mappa. Hashtables troppo offerte sincronizzati accesso per mappare, ma la vostra intera mappa è bloccato per eseguire qualsiasi operazione.

La logica dietro ConcurrentHashMap è che your entire table is not getting locked, ma solo la parte [segments]. Ogni segmenti gestisce un proprio HashTable. Blocco viene applicata solo per gli aggiornamenti. In caso di di recuperi, permette piena concorrenza.

prese quattro fili di Let stanno lavorando contemporaneamente su una mappa la cui capacità è 32, la tabella è suddivisa in quattro segmenti in cui ciascuno segmenti gestisce una tabella hash di capacità. La collezione mantiene una lista di 16 segmenti per impostazione predefinita, ognuno dei quali è utilizzato per custodire (o bloccare) In un singolo secchio della mappa.

Questo significa che 16 thread possono modificare l'insieme in una sola volta. Questo livello di concorrenza può essere aumentata tramite il programma opzionale concurrencyLevel costruttore argomento.

public ConcurrentHashMap(int initialCapacity,
                         float loadFactor, int concurrencyLevel)

Come l'altra risposta ha dichiarato, l'offerta ConcurrentHashMap nuovo metodo putIfAbsent() che è simile a mettere tranne il valore non sarà sovrascritto se la chiave esiste.

private static Map<String,String> aMap =new ConcurrentHashMap<String,String>();

if(!aMap.contains("key"))
   aMap.put("key","value");

Il nuovo metodo è anche più veloce in quanto evita double traversing come sopra. Metodo contains deve individuare il segmento e iterare il tavolo per trovare la chiave e di nuovo il metodo put deve attraversare il secchio e inserire la chiave.

Answer 3

In realtà la grande differenza funzionale è che non un'eccezione e / o finiscono per corrompere quando qualcun altro cambia mentre si sta utilizzando.

Con le collezioni regolari, se un altro thread di aggiungere o rimuovere un elemento, mentre si sta accedervi (tramite l'iteratore) sarà un'eccezione. ConcurrentHashMap permette loro di fare il cambiamento e non si ferma il tuo thread.

Intendiamoci non fa alcun tipo di garanzie di sincronizzazione o promesse circa la visibilità point-in-time del passaggio da un thread all'altro. (E 'una specie di isolamento database di lettura impegnata, piuttosto che una mappa sincronizzato che si comporta più come un isolamento di database serializzabile. (Vecchia scuola fila di blocco SQL serializzabile, non Oracle-ish multiversione serializzabile :))

L'uso più comune che conosco è in cache informazioni derivate immutabile in ambienti App server in cui molti fili possono essere accedono la stessa cosa, e non importa se due accada per calcolare lo stesso valore della cache e metterlo due volte perché interleave, ecc (ad esempio, è ampiamente utilizzato all'interno del framework Spring WebMVC per trattenere config runtime-derivato come mappature da URL a metodi del gestore.)

Answer 4

Può essere utilizzato per Memoizzazione:

import java.util.concurrent.ConcurrentHashMap;
public static Function<Integer, Integer> fib = (n) -> {
  Map<Integer, Integer> cache = new ConcurrentHashMap<>();
  if (n == 0 || n == 1) return n;
  return cache.computeIfAbsent(n, (key) -> HelloWorld.fib.apply(n - 2) + HelloWorld.fib.apply(n - 1));
};

Answer 5

1.ConcurrentHashMap è thread-safe che è il codice può accedere solo filo per volta.

sincronizza 2.ConcurrentHashMap o serrature sulla certa porzione della mappa. Per ottimizzare le prestazioni di ConcurrentHashMap, Map è diviso in diverse partizioni a seconda del livello di concorrenza. In modo che non abbiamo bisogno di sincronizzare l'intera mappa oggetto.

livello di concorrenza 3.Default è 16, pertanto mappa è divisa in 16 parti e ogni parte è regolato con un blocco diverso che mezzi 16 thread può funzionare.

4.ConcurrentHashMap non consente valori NULL. Quindi la chiave non può essere nullo in ConcurrentHashMap.

Answer 6

Ciao ragazzi oggi abbiamo discusso la ConcurrentHashMap.
Che cosa è ConcurrentHashMap?

ConcurrentHashMap è una classe che introduce in Java 1.5 che implementa il ConcurrentMap così come l'interfaccia Serializable. ConcurrentHashMap è migliorare la HashMap quando si occupano di molteplici Theading. Come sappiamo quando l'applicazione è multipla threading HashMap non è una buona scelta, perché si è verificato problema di prestazioni.

Ci sono alcuni il punto chiave della ConcurrentHashMap.

• struttura dati Underling per ConcurrentHashMap è HashTable.
• ConcurrentHashMap è una classe, tale classe è sicuro filo, significa accesso multiplo filo lattina su un singolo oggetto filo senza alcuna complicazione.
oggetto
• ConcurretnHashMap è diviso in diversi segmenti a seconda del livello di concorrenza.
• Il default Concurrency-livello di ConcurrentHashMap è 16.
• In ConcurrentHashMap qualsiasi numero di filo può eseguire l'operazione di recupero, ma per updation in oggetto Thread deve bloccare il particolare segmento in cui filo desidera operare.
• Questo tipo di meccanismo di bloccaggio è noto come Segment-bloccaggio o secchio-chiusura.
• In ConcurrentHashMap funzionamento 16 updation eseguire alla volta.
• Null inserimento non è possibile in ConcurrentHashMap.

Qui ci sono la costruzione ConcurrentHashMap.

1. ConcurrentHashMap m = new ConcurrentHashMap () ;: Crea una nuova mappa vuota con una capacità iniziale di default (16), fattore di carico (0,75) e concurrencyLevel (16).

2. ConcurrentHashMap m = new ConcurrentHashMap (int initialCapacity) ;: Crea una nuova mappa vuota con la capacità iniziale specificata, e con fattore di carico di default (0,75) e concurrencyLevel (16).

3. ConcurrentHashMap m = new ConcurrentHashMap (int initialCapacity, float loadFactor) ;: Crea una nuova mappa vuota con il fattore di capacità e caricamento iniziale specificato e con il difetto concurrencyLevel (16).

4. ConcurrentHashMap m = new ConcurrentHashMap (int initialCapacity, float loadFactor, int concurrencyLevel) ;: Crea una nuova mappa vuota con capacità iniziale specificata, fattore di carico e livello di concorrenza.

5. ConcurrentHashMap m = new ConcurrentHashMap (Mappa m) ;: Crea una nuova mappa con le stesse mappature come la mappa data.

ConcurretHashMap è un metodo chiamato è putIfAbsent ();. Questo metodo è evitare di memorizzare la chiave duplicata si rimanda al di sotto esempio

    import java.util.concurrent.*; 

     class ConcurrentHashMapDemo { 
     public static void main(String[] args) 
     { 
         ConcurrentHashMap m = new ConcurrentHashMap(); 
          m.put(1, "Hello"); 
          m.put(2, "Vala"); 
          m.put(3, "Sarakar"); 

         // Here we cant add Hello because 1 key 
         // is already present in ConcurrentHashMap object 

            m.putIfAbsent(1, "Hello"); 

         // We can remove entry because 2 key 
         // is associated with For value 

            m.remove(2, "Vala"); 

        // Now we can add Vala

            m.putIfAbsent(4, "Vala"); 


            System.out.println(m); 
      } 
}