Welche Möglichkeiten gibt es, Thread-Sicherheit für Map in Java zu implementieren?

Methode 1. Hashtable verwenden

Map<String,Object> hashtable=new Hashtable<String,Object>();

Das ist das Erste, woran jeder denkt, warum ist es also threadsicher? Dann werfen Sie einen Blick auf den Quellcode. Wir können sehen, dass unsere häufig verwendeten Methoden wie put, get und containsKey alle synchron sind, sodass sie threadsicher sind Hinzufügen, Löschen, Ändern und Überprüfen Der synchronisierte Sperrmechanismus wird in der Methode verwendet. Unabhängig davon, ob Daten gelesen oder geändert werden, kann aufgrund der gesamten Tabelle nur ein Thread gleichzeitig die Synchronisierungsmethode ausführen ist gesperrt. Je mehr Threads vorhanden sind, desto intensiver ist der Wettbewerb um die Karte und desto geringer ist die Effizienz. Dies wird nicht empfohlen.

Methode 2. Verwenden Sie Collections.synchronizedMap(new Hashtable())

Das Implementierungsprinzip besteht darin, die statische Methode in der Tool-Klasse zu verwenden, um die eingehende Hashtable in die Synchronisierung zu packen. Das heißt, der Methode zum Hinzufügen, Löschen, Ändern und Überprüfen wird ein synchronisierter Mechanismus hinzugefügt. Die Implementierungsmethode ähnelt der von Hashtable und die Verwendung wird nicht empfohlen.

public synchronized boolean containsKey(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return true;
            }
        }
        return false;
    }

 public synchronized V get(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return (V)e.value;
            }
        }
        return null;
    }
     public synchronized V put(K key, V value) {
        // Make sure the value is not null
        if (value == null) {
            throw new NullPointerException();
        }

        // Makes sure the key is not already in the hashtable.
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        Entry<K,V> entry = (Entry<K,V>)tab[index];
        for(; entry != null ; entry = entry.next) {
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }

        addEntry(hash, key, value, index);
        return null;
    }

Das Folgende ist der JDK-Quellcode

Map map = Collections.synchronizedMap(new Hashtable());

Methode 3. Verwenden Sie ConcurrentHashMap

Das Implementierungsprinzip besteht darin, dass Hashtable die gesamte Tabelle sperrt und ConcurrentHashMap Die Tabelle ist zunächst in 16 Segmente unterteilt. Wenn mehrere Threads auf verschiedene Segmente zugreifen, können sie parallel aufgerufen werden. Die Effizienz ist viel höher als bei Hashtable, daher wird die Verwendung empfohlen.

Das obige ist der detaillierte Inhalt vonWelche Möglichkeiten gibt es, Thread-Sicherheit für Map in Java zu implementieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!