L'exception ConcurrentModificationException se produit lorsqu'on tente de modifier simultanément un objet alors que cela n'est pas autorisé. Cette exception survient généralement lorsque l'on travaille avec Classes de collection Java .

Par exemple - Il n'est pas permis à un thread de modifier une collection lorsqu'un autre thread la parcourt. En effet, le résultat de l'itération devient indéfini avec celle-ci. Certaines implémentations de la classe Iterator lèvent cette exception, y compris toutes les implémentations générales d'Iterator fournies par le JRE. Les itérateurs qui font cela sont appelés échec rapide car ils lèvent l'exception rapidement dès qu'ils rencontrent une telle situation plutôt que de faire face à un comportement indéterminé de la collection à tout moment dans le futur.

ouvrir un fichier avec java

Note:Il n'est pas obligatoire que cette exception soit levée uniquement lorsqu'un autre thread tente de modifier un objet Collection. Cela peut également se produire si un seul thread a appelé des méthodes qui tentent de violer le contrat de l'objet. Cela peut se produire lorsqu'un thread tente de modifier l'objet Collection alors qu'il est itéré par certains.itérateur à échec rapide, l'itérateur lèvera l'exception.

Exemple

 import java.awt.List; import java.util.*; public class Concurrentmodificationexception { public static void main(String[] args) { ArrayList list = new ArrayList(); list.add(1); list.add(2); list.add(3); list.add(4); list.add(5); Iterator it = list.iterator(); while (it.hasNext()) { Integer value = it.next(); System.out.println('List Value:' + value); if (value.equals(3)) list.remove(value); } } } 

Sortir:

Ce message indique que l'exception est levée lorsque la méthode suivante est appelée lorsque l'itérateur parcourt la liste et que nous y apportons des modifications simultanément. Mais si nous apportons des modifications au hashmap comme indiqué ci-dessous, aucune exception de ce type ne sera levée car la taille du hashmap ne changera pas.

Par exemple-

 import java.awt.List; import java.util.*; public class concurrentmodificationexception { public static void main(String[] args) { HashMap map = new HashMap(); map.put(1, 1); map.put(2, 2); map.put(3,3); Iterator it = map.keySet().iterator(); while(it.hasNext()) { Integer key = it.next(); System.out.println('Map Value:' + map.get(key)); if (key.equals(2)) { map.put(1, 4); } } } } 

Sortir:

flotter en chaîne

 Map Value:1 Map Value:2 Map Value:3 

Cet exemple fonctionne parfaitement car pendant que l'itérateur parcourt la carte, la taille de la carte ne change pas. Seule la carte est en cours de mise à jour dans le si déclaration .

Constructeurs de ConcurrentModificationException

Il existe 4 types de constructeurs de ConcurrentModificationException -

dormir pour javascript

1. public ConcurrentModificationException() -
   Cela crée une ConcurrentModificationException sans paramètres.
2. public ConcurrentModificationException (message de chaîne)
   Cela crée une ConcurrentModificationException avec un message détaillé spécifiant l'exception.
3. public ConcurrentModificationException (cause jetable)
   Cela crée une ConcurrentModificationException avec une cause et un message qui est (cause==null?null:cause.toString()). La cause est ensuite récupérée par Throwable.getCause().
4. public ConcurrentModificationException (message de chaîne, cause pouvant être lancée)
   Cela crée une ConcurrentModificationException avec un message détaillé et une cause. (cause==null?null:cause.toString()). Le message est ensuite récupéré par Throwable.getMessage() et la cause est ensuite récupérée par Throwable.getCause().

Comment éviter ConcurrentModificationException dans un environnement multithread ?

Pour éviter l'exception ConcurrentModificationException dans un environnement multithread, nous pouvons suivre les méthodes suivantes :

1. Au lieu de parcourir la classe de collection, nous pouvons parcourir le tableau. De cette façon, nous pouvons très bien travailler avec des listes de petite taille, mais cela réduira les performances si la taille du tableau est très grande.
2. Une autre façon peut être de verrouiller la liste en la plaçant dans le bloc synchronisé. Ce n’est pas une approche efficace car cela abandonne le seul objectif de l’utilisation du multithreading.
3. JDK 1.5 ou supérieur fournit les classes ConcurrentHashMap et CopyOnWriteArrayList. Ces classes nous aident à éviter les exceptions de modification simultanée.

Comment éviter ConcurrentModificationException dans un environnement monothread ?

En utilisant la fonction Remove() de l'itérateur, vous pouvez supprimer un objet d'un objet de collection sous-jacent.