ik heb een thread-safe map nodig, ik heb zoiets als dit: (ik ben erg nieuw bij 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
        }
        }

Antwoord 1, autoriteit 100%

java.util.concurrent.ConcurrentHashMap

Antwoord 2, autoriteit 35%

De ConcurrentHashMapuit het pakket java.util.concurrentis een threadveilige implementatie van Map die een veel betere gelijktijdigheid biedt dan synchronizedMap(en veel betere schaalbaarheid dan Hashtable). Zie http://www.ibm.com/developerworks/java/library/ j-jtp07233.html.

Antwoord 3, autoriteit 9%

Gebruik ConcurrentHashMap

Antwoord 4, autoriteit 2%

Uw code zou er zo uit moeten zien, imports, et al. negerend.

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
    }
}

Dat gezegd hebbende, pas op dat dit niet zo threadveilig is als je zou hopen. Zoals anderen al hebben vermeld, wilt u waarschijnlijk de Java Gelijktijdige Collecties.

Antwoord 5, autoriteit 2%

Interfaces

Java bundelt een paar interfaces voor een gelijktijdige Map:

• ConcurrentMap
• ConcurrentNavigableMap

De eerste maakt thread-safetyen atomiciteitgaranties. De tweede voegt die garanties toe aan NavigableMapimplementaties die hun sleutels in een bepaalde volgorde houden.

Klassen

Aanpasbare kaarten

Java biedt twee klassen die deze interfaces implementeren. Bibliotheken van derden kunnen ook klassen leveren die deze interfaces implementeren. De klassen die bij Java worden geleverd zijn:

• ConcurrentHashMap(voor ConcurrentMap)
• ConcurrentSkipListMap(voor ConcurrentMapen ConcurrentNavigableMap)

Voorbeeld van gebruik:

ConcurrentMap < Project , Person > map = new ConcurrentHashMap<>() ;

…en:

ConcurrentNavigableMap < Month , Person > map = new ConcurrentSkipListMap <>() ;

Onaanpasbare kaarten

Als een niet-aanpasbare-kaart werkt voor u, zie de Map.of, Map.ofEntries, en Map.copyOfmethoden. Niet-aanpasbaar zijn zorgt voor thread-veilige alleen-lezen toegang.

Verouderde kaart

Er is een legacy-klasse, Hashtable, die over het algemeen niet meer wordt gebruikt. Maar voor de volledigheid moeten we deze klasse vermelden vanwege de gesynchroniseerde-methoden die zorgen voor draadveiligheid. Om de JavaDoc te citeren:

Als een thread-veilige implementatie niet nodig is, wordt aanbevolen om HashMapte gebruiken in plaats van Hashtable. Als een thread-safe zeer gelijktijdige implementatie gewenst is, wordt aanbevolen om ConcurrentHashMapte gebruiken in plaats van Hashtable.

Tabel met Mapklassen

Hier is een grafische tabel die ik heb gemaakt met verschillende kenmerken van de verschillende Mapimplementaties gebundeld met Java 11.

Zoek naar de rode vakken in de kolom Gelijktijdigheid.

Antwoord 6

Uw kaart “lijst” moet statisch zijn als u deze wilt openen in een statisch blok.

Antwoord 7

U kunt een objectlidvariabele niet initialiseren in een statisch blok. Statische blokken worden één keer uitgevoerd wanneer de klasse voor het eerst wordt geladen, niet één keer voor elk object van die klasse, terwijl de variabele “lijst” één keer wordt gemaakt voor elk object van de klasse.

Je kunt ook geen “nieuwe kaart” instantiëren, omdat kaart een interface is. Je moet de gesynchroniseerde kaart om een ​​echte kaart wikkelen, zoals een HashMap of een TreeMap.

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

Antwoord 8

van java.util.concurrent

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

van java.util.Collections

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