Java ConcurrentModificationException

Java Programming Language propose une gamme de cas de gestion des exceptions, et Concurrent Modification Exception en fait partie. Une exception de modification simultanée se produit lorsqu'un thread d'un programme tente de modifier un objet qui ne dispose pas des autorisations nécessaires pour être modifié pendant le processus en cours. Donc simplement, lorsque nous tentons de modifier un objet actuellement utilisé par un autre processus, la ConcurrentModificationException apparaîtra.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Un exemple très simple serait une collection qui a été traitée par un thread. La collection en cours de processus ne peut pas être modifiée et lève donc ConcurrentModificationException.

Syntaxe :

Vous trouverez ci-dessous la syntaxe la plus simple pour l'exception. ConcurrentModificationException fait partie du langage Java RunTimeException et l'étend.

public class Concurrent Modification Exception
extends Runtime Exception

Comment fonctionne ConcurrentModificationException en Java ?

Il est compréhensible que nous fixions certaines limites et autorisations en fonction de nos besoins lorsque nous créons des objets en Java. Mais parfois, nous essayons de changer les valeurs ou de modifier la liste, juste au moment où elle est dans le fil, et c'est à ce moment-là que ConcurrentModificationException apparaît car l'objet a été utilisé par un autre fil et ne peut pas être modifié ou amendé.

Il est également important de savoir que cette exception ne signifie pas toujours qu’un objet est modifié simultanément. Dans le cas d'un seul thread, cette exception peut être levée si des invocations de méthodes ont lieu, ce qui viole d'une manière ou d'une autre le contrat d'objet.

Constructeurs :

Un constructeur très basique pour ConcurrentModificationException est aussi simple que suivant : ConcurrentModificationException (). Outre le simple constructeur, nous avons les contributeurs suivants qui peuvent être utilisés selon les besoins :

• ConcurrentModificationException (String textmessage): Constructeur avec un message simple.
• ConcurrentModificationException (String textmessage, Throwable textcause) : Constructeur avec un message et une cause détaillée.
• ConcurrentModificationException ( Throwable textcause): Constructeur avec une cause, ici la cause peut être nulle, ce qui signifie qu'elle est inconnue.

Exemples d'exception Java ConcurrentModificationException

Maintenant que nous avons compris ce qu'est l'exception de modification simultanée et comment elle fonctionne, passons à la mise en œuvre. Nous allons maintenant comprendre l'exception avec un exemple ; par exemple, nous aurons une liste de tableaux et, parallèlement à certaines opérations, nous tenterons de la modifier, ce qui entraînera une exception. Le code de l'exemple est le suivant :

Exemple n°1

Code :

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

Explication du code : Commencé avec quelques fichiers d'importation, puis la décélération de classe et la méthode principale. Initialisez la liste des tableaux et ajoutez une fonction pour continuer à ajouter un nombre ; de cette façon, ce sera en cours de traitement. À chaque ajout suivant, nous imprimons la valeur de la liste. Mais nous avons ensuite une boucle if, qui recherchera un nombre égal à 3, et une fois que 3 sera trouvé, elle tentera de supprimer le nombre, et c'est là que l'exception se rencontrera et le programme sera terminé. Il n’y aura plus d’ajouts à la liste.

Si vous exécutez le code ci-dessus sans aucune erreur, le code tombera sur une exception. Cette exception se trouve dans ConcurrentModificationException.main ( ConcurrentModificationException.java:14). La raison de cette exception est claire : nous avons tenté de modifier une liste, Numberlist. Reportez-vous à la capture d'écran ci-jointe pour un résultat correct :

Comme vous pouvez le voir, le programme a été exécuté comme prévu, les instructions print exécutées avec succès jusqu'à ce qu'elles atteignent la valeur 3. Le déroulement du programme a été interrompu à la valeur 3 car nous avions une boucle if, qui semble pour une valeur égale à trois et la supprime. Mais l'itérateur est déjà en cours et la tentative de suppression du 3 échouera, ce qui lèvera l'exception ConcurrentModificationException.

Exemple n°2

pour les besoins du deuxième exemple, nous tenterons d'exécuter un programme qui réussira à éviter l'exception de modification simultanée. Dans le même code, si nous essayons de modifier la liste des tableaux pendant le processus, elle interceptera l'exception ConcurrentModificationException et le programme sera terminé. Le code du deuxième exemple est le suivant :

Code :

import java.util.Iterator;
import java.util.ArrayList;
public class ConcurrentModificationException {
public static void main ( String args[])
{
ArrayList<String> arraylist = new ArrayList<String> ( ) ;
arraylist.add ( "One") ;
arraylist.add ( "Two") ;
arraylist.add ( "Three") ;
arraylist.add ( "Four") ;
try {
System.out.println ( "ArrayList: ") ;
Iterator<String> iteratornew = arraylist.iterator () ;
while ( iteratornew.hasNext ( ) ) {
System.out.print ( iteratornew.next ()
+ ", ");
}
System.out.println ( "\n\n Trying to add an element in between iteration:"
+ arraylist.add ( "Five") ) ;
System.out.println ( "\n Updated ArrayList: \n") ;
iteratornew = arraylist.iterator () ;
while ( iteratornew.hasNext ( ) ) {
System.out.print ( iteratornew.next ()
+ ", ");
}
}
catch ( Exception e) {
System.out.println ( e) ;
}
}
}

Code Explanation: Similar to the earlier program, we have the required files and methods. We are simply adding a few elements to the array list, and it is iterating; we add another element, which is Five. We will print the updated list upon the latest additions, which will have our newly added element. We have implemented the try-catch block to catch the exception. If any exception occurs, it will print the exception.

Output:

As you can see in the output, the first array list is plain, with few elements. Then in the next line, we attempt to add an element while in iteration, the element is “Five”. It is successfully added, and it prints true for the sentence. And in the next line, we print an updated list, which has the Five-element. We have updated the list after the process is ending; if we try to add the element while in the process, it will throw the ConcurrentModificationException, and the program will cease.

How to Avoid ConcurrentModificationException in Java?

Avoiding Concurrent Modification Exception is possible on a different level of threads. To avoid a Concurrent Exception with a single thread environment, you can remove the object from the iterator and modify it, use remove ().

And in the case of a multi-thread environment, you have few choices like converting the list in the process into an array and then working on the array. Then you can also put a synchronized block over a list and lock it. But locking the list is not recommended as it may limit the advantages of multi-threading programming. Using a sublist to modify a list will result in nothing. Out of all the ways to avoid, the most preferred way is to wait until the execution is finished and then edit or modify the list or the object.

Conclusion

When a process is using one resource and another process attempts to edit or amend it, the exception ConcurrentModificationException will be thrown. The simplest method to avoid is to modify the list after iteration. Many methods are listed to avoid the exception but advised to implement them with small programs.

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!