filo mappa sicuro per java

Question

ho bisogno di una mappa thread-safe, ho qualcosa di simile a questa: (io sono molto nuovo a Java)

public static class Manager 
     { 
     static 
     { 
//something wrong here, doesn't compile 
      list = new java.util.Collections 
      .synchronizedMap(new Map<String, Client>()); 
     } 

     static Map<String,Client> list; 

     public static void AddClient(Client client) 
     { 
     // thread safe add client to the list 
     } 

     public static void RemoveClient(Client client) 
     { 
     // thread safe remove client to the list 
     } 

     } 

Answer 1

java.util.concurrent.ConcurrentHashMap

Answer 2

Usa ConcurrentHashMap

Answer 3

tua mappa "elenco" deve essere statico se si desidera accedervi in ​​un blocco statico.

Answer 4

Il tuo codice dovrebbe apparire come questo, ignorando le importazioni, et al.

public class Manager 
{ 
    Map<String,Client> list = java.util.Collections.synchronizedMap(new HashMap<String, Client>()); 

    public void AddClient(Client client) 
    { 
     // thread safe add client to the list 
    } 

    public void RemoveClient(Client client) 
    { 
     // thread safe remove client to the list 
    } 
} 

Detto questo, fai attenzione che questo non è un thread sicuro come potresti sperare. Come altri hanno già detto, probabilmente vorrai usare lo Java Concurrent Collections.

Answer 5

Non è possibile inizializzare una variabile membro dell'oggetto in un blocco statico. I blocchi statici vengono eseguiti una volta quando la classe viene caricata per la prima volta, non una volta per ogni oggetto di quella classe, mentre la variabile "lista" viene creata una volta per ogni oggetto della classe.

Inoltre, non è possibile creare un'istanza di una "nuova mappa" perché la Mappa è un'interfaccia. È necessario avvolgere la mappa sincronizzata attorno a una mappa reale come una HashMap o una TreeMap.

 { 
      list = new java.util.Collections 
      .synchronizedMap(new HashMap<String, Client>()); 
     } 

Answer 6

Il ConcurrentHashMap classe dalla confezione java.util.concurrent è un'implementazione thread-safe di Map, che offre di gran lunga migliore concorrenza di synchronizedMap (e di gran lunga superiore scalabilità nel Hashtable). Vedi http://www.ibm.com/developerworks/java/library/j-jtp07233.html.

Answer 7

da java.util.concurrent

ConcurrentHashMap<K,V> 
ConcurrentMap<K,V> 
ConcurrentNavigableMap<K,V> 
ConcurrentHashMap<K,V> 
ConcurrentSkipListMap<K,V> 

da java.util.Collections

Collections.synchronizedMap(Map<K,V> m) 
Collections.synchronizedNavigableMap(NavigableMap<K,V> m) 
Collections.synchronizedSortedMap(SortedMap<K,V> m)