Méthodes pour résoudre l'exception de modification simultanée Java (ConcurrentModificationException)

Méthodes pour résoudre l'exception de modification simultanée Java (ConcurrentModificationException)

Dans la programmation Java, lorsque plusieurs threads lisent et écrivent une collection en même temps, il est facile qu'une exception de modification simultanée (ConcurrentModificationException) se produise. Cette exception se produit généralement lors de l'utilisation d'un itérateur pour parcourir une collection, tandis que d'autres threads modifient la collection. Cet article présentera quelques méthodes courantes pour résoudre cette exception et donnera des exemples de code correspondants.

1. Utilisez des classes de collection thread-safe

Java fournit des classes de collection thread-safe, telles que java.util.concurrent.CopyOnWriteArrayList et java.util.concurrent.ConcurrentHashMap code code>. Ces classes de collection utilisent un mécanisme spécial de copie sur écriture pour garantir qu'aucune exception de modification simultanée ne se produira lorsque des opérations de modification sont effectuées pendant le processus de parcours. Voici un exemple de code utilisant CopyOnWriteArrayList : java.util.concurrent.CopyOnWriteArrayList和java.util.concurrent.ConcurrentHashMap。这些集合类使用了一种特殊的写时复制机制，可以保证在遍历过程中进行了修改操作时，不会产生并发修改异常。下面是使用CopyOnWriteArrayList的示例代码：

List<String> list = new CopyOnWriteArrayList<>();
list.add("hello");
list.add("world");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
    list.add("!");
}

2. 使用同步块或锁机制

另一种解决并发修改异常的方法是使用同步块或锁机制。通过在多个线程访问集合时，确保只有一个线程能够修改集合，可以避免并发修改异常的发生。下面是使用同步块的示例代码：

List<String> list = new ArrayList<>();
list.add("hello");
list.add("world");

synchronized (list) {
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        String element = iterator.next();
        System.out.println(element);
        list.add("!");
    }
}

3. 使用并发容器的迭代器

Java的并发容器类提供了专门用于并发访问的迭代器。使用这些迭代器可以在遍历过程中适应集合的修改，避免并发修改异常的发生。下面是使用ConcurrentHashMap的示例代码：

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("java", 1);
map.put("python", 2);

Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Integer> entry = iterator.next();
    String key = entry.getKey();
    int value = entry.getValue();
    System.out.println(key + ": " + value);
    map.put("c++", 3);
}

4. 使用Iterator的删除方法

在遍历集合时，使用Iterator的remove()方法可以安全地删除元素，而不会引发并发修改异常。下面是使用remove()方法的示例代码：

List<String> list = new ArrayList<>();
list.add("hello");
list.add("world");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
    if (element.equals("hello")) {
        iterator.remove();
    }
}

总结：

并发修改异常是Java编程中常见的问题之一，但我们可以采用多种方法来解决。使用线程安全的集合类、同步块或锁机制、并发容器的迭代器以及Iteratorrrreee

Utilisation d'un bloc synchronisé ou d'un mécanisme de verrouillage
🎜Une autre façon de résoudre les exceptions de modification simultanées consiste à utiliser un bloc synchronisé ou mécanisme de verrouillage. En garantissant qu'un seul thread peut modifier la collection lorsque plusieurs threads accèdent à la collection, les exceptions de modification simultanées peuvent être évitées. Voici un exemple de code utilisant des blocs synchronisés : 🎜rrreee
🎜Utilisation d'itérateurs de conteneurs simultanés🎜🎜🎜La classe de conteneurs simultanés de Java fournit des itérateurs spécifiquement pour l'accès simultané. L'utilisation de ces itérateurs peut s'adapter aux modifications apportées à la collection au cours du processus de parcours et éviter l'apparition d'exceptions de modification simultanées. Voici un exemple de code utilisant ConcurrentHashMap : 🎜rrreee
🎜Utilisez la méthode de suppression de Iterator🎜🎜🎜Lorsque vous parcourez la collection, utilisez remove() de code> Iterator peut supprimer des éléments en toute sécurité sans déclencher d'exceptions de modification simultanées. Voici un exemple de code utilisant la méthode remove() : 🎜rrreee🎜Résumé : 🎜🎜L'exception de modification simultanée est l'un des problèmes courants dans la programmation Java, mais nous pouvons utiliser de nombreuses méthodes pour le résoudre. L'utilisation de classes de collection thread-safe, de blocs synchronisés ou de mécanismes de verrouillage, d'itérateurs de conteneurs simultanés et de méthodes de suppression de Iterator peut efficacement éviter l'apparition d'exceptions de modification simultanées. Au cours du processus de développement, le choix de la méthode appropriée pour résoudre le problème de l'accès simultané aux collections en fonction de besoins spécifiques peut garantir la stabilité et l'exactitude du programme. 🎜🎜 (Ce qui précède est un article de 1 500 mots, intitulé "Méthodes pour résoudre l'exception de modification simultanée Java (ConcurrentModificationException)") 🎜

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!