Comment utiliser la fonction ConcurrentHashMap pour les opérations de mappage simultanées en Java

Avec la prolifération des processeurs multicœurs, la programmation simultanée dans les applications informatiques est devenue une compétence de plus en plus importante. En Java, ConcurrentHashMap est une structure de données de table de mappage simultané efficace qui peut répondre aux besoins d'accès simultané tout en garantissant la sécurité des threads. Cet article explique comment utiliser la fonction ConcurrentHashMap en Java pour effectuer des opérations de mappage simultanées.

ConcurrentHashMap est une implémentation de table de hachage thread-safe introduite dans Java 5. Comparé à Hashtable et SynchronizedMap, il offre de meilleures performances de concurrence. Semblable à Hashtable et SynchronizedMap, ConcurrentHashMap est également une table de mappage de paires clé-valeur, mais elle utilise la technologie de verrouillage segmenté pour réduire la concurrence entre les verrous.

Utiliser ConcurrentHashMap en Java est simple. Tout d’abord, vous devez importer le package java.util.concurrent.ConcurrentHashMap, puis créer un objet ConcurrentHashMap.

import java.util.concurrent.ConcurrentHashMap;

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

Dans le code ci-dessus, nous avons créé un objet ConcurrentHashMap pour stocker les paires clé-valeur, où le type de clé est String et le type de valeur est Integer.

Fonctions ConcurrentHashMap couramment utilisées
Voici les fonctions couramment utilisées dans ConcurrentHashMap et comment les utiliser.

1. put()
   Ajoute la paire clé-valeur spécifiée à ConcurrentHashMap. Si la clé spécifiée existe déjà, la valeur correspondante est mise à jour et l'ancienne valeur est renvoyée. Si la clé spécifiée n'existe pas, une nouvelle paire clé-valeur est ajoutée et null est renvoyé.

   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()
   Obtenir la valeur correspondant à la clé spécifiée. Si la clé n'existe pas, renvoie null.

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

3. remove()
   Supprimez la paire clé-valeur spécifiée. Si la clé n'existe pas, renvoie null.

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

4. replace()
   Remplacez la valeur correspondant à la clé spécifiée. Si la clé n'existe pas, renvoie null.

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

5. putIfAbsent()
   Si la clé spécifiée n'existe pas, ajoutez une nouvelle paire clé-valeur et renvoyez null. Si la clé spécifiée existe déjà, la valeur correspondante est renvoyée.

   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()
   Obtenez le nombre de paires clé-valeur dans ConcurrentHashMap.

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

7. clear()
   Supprimez toutes les paires clé-valeur dans ConcurrentHashMap.

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

Exemple de code
Ce qui suit est un exemple simple montrant comment utiliser la fonction ConcurrentHashMap pour les opérations de mappage simultanées. Dans cet exemple, nous allons démarrer plusieurs threads pour ajouter des paires clé-valeur à ConcurrentHashMap et accéder simultanément aux paires clé-valeur.

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();
    }
}

Dans cet exemple, nous démarrons deux threads, un thread est utilisé pour ajouter des paires clé-valeur à ConcurrentHashMap et l'autre thread est utilisé pour accéder aux paires clé-valeur. Dans le thread d'accès, nous utilisons la fonction get() de ConcurrentHashMap pour obtenir la valeur de la paire clé-valeur.

Les résultats de sortie sont les suivants :

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

Vous pouvez voir que l'ajout de threads et l'accès aux threads s'exécutent en même temps, et qu'il n'y aura pas de concurrence entre les threads. ConcurrentHashMap garantit la sécurité des threads et des performances de concurrence élevées.

Résumé
Cet article explique comment utiliser la fonction ConcurrentHashMap en Java pour effectuer des opérations de mappage simultanées. En utilisant ConcurrentHashMap, nous pouvons améliorer les performances de concurrence du programme et garantir la sécurité des threads dans les scénarios multithread. Que vous développiez des applications réseau à haute concurrence ou des systèmes distribués traitant des données à grande échelle, ConcurrentHashMap est un outil très pratique.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!