So verwenden Sie die ConcurrentHashMap-Funktion für gleichzeitige Zuordnungsvorgänge in Java

Mit der Verbreitung von Mehrkernprozessoren ist die gleichzeitige Programmierung in Computeranwendungen zu einer immer wichtigeren Fähigkeit geworden. In Java ist ConcurrentHashMap eine effiziente Datenstruktur für gleichzeitige Zuordnungstabellen, die die Anforderungen des gleichzeitigen Zugriffs erfüllen und gleichzeitig die Thread-Sicherheit gewährleisten kann. In diesem Artikel wird erläutert, wie Sie die ConcurrentHashMap-Funktion in Java verwenden, um gleichzeitige Zuordnungsvorgänge durchzuführen.

ConcurrentHashMap ist eine threadsichere Hash-Tabellenimplementierung, die in Java 5 eingeführt wurde. Im Vergleich zu Hashtable und SynchronizedMap weist es eine bessere Parallelitätsleistung auf. Ähnlich wie Hashtable und SynchronizedMap ist ConcurrentHashMap ebenfalls eine Zuordnungstabelle von Schlüssel-Wert-Paaren, verwendet jedoch die segmentierte Sperrtechnologie, um die Sperrkonkurrenz zu verringern.

Die Verwendung von ConcurrentHashMap in Java ist einfach. Zuerst müssen Sie das Paket java.util.concurrent.ConcurrentHashMap importieren und dann ein ConcurrentHashMap-Objekt erstellen.

import java.util.concurrent.ConcurrentHashMap;

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

Im obigen Code haben wir ein ConcurrentHashMap-Objekt zum Speichern von Schlüssel-Wert-Paaren erstellt, wobei der Schlüsseltyp String und der Werttyp Integer ist.

Häufig verwendete ConcurrentHashMap-Funktionen
Im Folgenden sind die häufig verwendeten Funktionen in ConcurrentHashMap und deren Verwendung aufgeführt.

1. put()
   Fügt das angegebene Schlüssel-Wert-Paar zu ConcurrentHashMap hinzu. Wenn der angegebene Schlüssel bereits vorhanden ist, wird der entsprechende Wert aktualisiert und der alte Wert zurückgegeben. Wenn der angegebene Schlüssel nicht vorhanden ist, wird ein neues Schlüssel-Wert-Paar hinzugefügt und null zurückgegeben.

   Integer oldValue = map.put("a", 1); // 添加键值对a=1，返回null
   Integer value = map.put("b", 2); // 添加键值对b=2，返回null
   Integer newValue = map.put("a", 3); // 更新键值对a=3，返回旧值1

2. get()
   Erhalten Sie den Wert, der dem angegebenen Schlüssel entspricht. Wenn der Schlüssel nicht vorhanden ist, wird null zurückgegeben.

   Integer value = map.get("a"); // 获取键a对应的值3

3. remove()
   Löschen Sie das angegebene Schlüssel-Wert-Paar. Wenn der Schlüssel nicht vorhanden ist, wird null zurückgegeben.

   Integer value = map.remove("a"); // 删除键a对应的键值对，返回值3

4. replace()
   Ersetzen Sie den Wert, der dem angegebenen Schlüssel entspricht. Wenn der Schlüssel nicht vorhanden ist, wird null zurückgegeben.

   Integer oldValue = map.replace("b", 4); // 替换键b对应的值为4，返回旧值2

5. putIfAbsent()
   Wenn der angegebene Schlüssel nicht existiert, fügen Sie ein neues Schlüssel-Wert-Paar hinzu und geben Sie null zurück. Wenn der angegebene Schlüssel bereits existiert, wird der entsprechende Wert zurückgegeben.

   Integer oldValue = map.putIfAbsent("a", 5); // putIfAbsent会判断键a是否存在，因为键a已经存在于ConcurrentHashMap中，此次添加操作不会执行，返回a对应的旧值3
   Integer value = map.putIfAbsent("c", 6); // putIfAbsent会判断键c是否存在，因为键c不存在于ConcurrentHashMap中，此次添加键值对c=6操作会执行，返回null

6. size()
   Ermitteln Sie die Anzahl der Schlüssel-Wert-Paare in ConcurrentHashMap.

   int size = map.size(); // 获取ConcurrentHashMap中键值对的数量

7. clear()
   Alle Schlüssel-Wert-Paare in ConcurrentHashMap löschen.

   map.clear(); // 删除ConcurrentHashMap中的所有键值对

Beispielcode
Das Folgende ist ein einfaches Beispiel, das zeigt, wie die ConcurrentHashMap-Funktion für gleichzeitige Zuordnungsvorgänge verwendet wird. In diesem Beispiel starten wir mehrere Threads, um Schlüssel-Wert-Paare zu ConcurrentHashMap hinzuzufügen und gleichzeitig auf die Schlüssel-Wert-Paare zuzugreifen.

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapDemo {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        // 添加键值对的线程
        Thread addThread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                map.put(String.valueOf(i), i);
            }
        });

        // 访问键值对的线程
        Thread visitThread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                Integer value = map.get(String.valueOf(i));
                System.out.println(Thread.currentThread().getName() + " " + value);
            }
        });

        addThread.start();
        visitThread.start();

        addThread.join();
        visitThread.join();
    }
}

In diesem Beispiel starten wir zwei Threads, ein Thread wird verwendet, um Schlüssel-Wert-Paare zu ConcurrentHashMap hinzuzufügen, und der andere Thread wird verwendet, um auf Schlüssel-Wert-Paare zuzugreifen. Im Zugriffsthread verwenden wir die Funktion get() von ConcurrentHashMap, um den Wert des Schlüssel-Wert-Paares abzurufen.

Das Ausgabeergebnis lautet wie folgt:

Thread-1 0
Thread-1 1
Thread-1 2
Thread-1 3
Thread-1 4
.
.
.
Thread-1 97
Thread-1 98
Thread-1 99

Es ist ersichtlich, dass der Additions-Thread und der Zugriffs-Thread gleichzeitig ausgeführt werden und es keine Konkurrenz zwischen Threads gibt. ConcurrentHashMap gewährleistet Thread-Sicherheit und hohe Parallelitätsleistung.

Zusammenfassung
In diesem Artikel wird erläutert, wie Sie die ConcurrentHashMap-Funktion in Java verwenden, um gleichzeitige Zuordnungsvorgänge durchzuführen. Durch die Verwendung von ConcurrentHashMap können wir die Parallelitätsleistung des Programms verbessern und die Thread-Sicherheit in Multithread-Szenarien gewährleisten. Unabhängig davon, ob Sie Netzwerkanwendungen mit hoher Parallelität oder verteilte Systeme entwickeln, die große Datenmengen verarbeiten, ist ConcurrentHashMap ein sehr praktisches Werkzeug.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die ConcurrentHashMap-Funktion für gleichzeitige Zuordnungsvorgänge in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!