Java Programming Language bietet eine Reihe von Ausnahmebehandlungsfällen, und Concurrent Modification Exception ist einer davon. Eine gleichzeitige Änderungsausnahme tritt auf, wenn ein Thread in einem Programm versucht, ein Objekt zu ändern, das im aktuellen Prozess keine Bearbeitungsberechtigung hat. Wenn wir also versuchen, ein Objekt zu bearbeiten, das derzeit von einem anderen Prozess verwendet wird, wird die ConcurrentModificationException angezeigt.
Starten Sie Ihren kostenlosen Softwareentwicklungskurs
Webentwicklung, Programmiersprachen, Softwaretests und andere
Ein sehr einfaches Beispiel wäre eine Sammlung, die von einem Thread verarbeitet wurde. Die verarbeitete Sammlung darf nicht geändert werden und löst daher eine ConcurrentModificationException aus.
Syntax:
Unten finden Sie die einfachste Syntax für die Ausnahme. ConcurrentModificationException ist Teil der Java Lang RunTimeException und erweitert diese.
public class Concurrent Modification Exception extends Runtime Exception
Es ist verständlich, dass wir beim Erstellen von Objekten in Java einige Grenzen und Berechtigungen entsprechend unseren Anforderungen festlegen. Aber manchmal versuchen wir, die Werte zu ändern oder die Liste zu ergänzen, gerade wenn sie sich im Thread befindet, und dann erscheint ConcurrentModificationException, weil das Objekt von einem anderen Thread verwendet wurde und nicht bearbeitet oder geändert werden kann.
Es ist auch wichtig zu wissen, dass diese Ausnahme nicht immer bedeutet, dass gleichzeitig ein Objekt geändert wird. Im Falle eines einzelnen Threads kann diese Ausnahme ausgelöst werden, wenn Methodenaufrufe stattfinden, die in irgendeiner Weise gegen den Objektvertrag verstoßen.
Konstrukteure:
Ein sehr einfacher Konstruktor für ConcurrentModificationException ist so einfach wie folgt: ConcurrentModificationException (). Außer dem einfachen Konstruktor verfügen wir über die folgenden Mitwirkenden, die je nach Bedarf verwendet werden können:
Da wir nun verstanden haben, was die Concurrent Modification Exception ist und wie sie funktioniert, gehen wir zur Implementierung über. Wir werden die Ausnahme nun anhand eines Beispiels verstehen; Wir haben zum Beispiel eine Array-Liste und werden zusammen mit einer Operation versuchen, sie zu ändern, was zu einer Ausnahme führt. Der Code für das Beispiel lautet wie folgt:
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) ;
}
}
}Code-Erklärung: Begonnen mit ein paar Importdateien, dann Klassenverlangsamung und der Hauptmethode. Initialisierte die Array-Liste und fügte eine Funktion hinzu, um weiterhin eine Zahl hinzuzufügen; Auf diese Weise wird es bearbeitet. Bei jeder nächsten Hinzufügung drucken wir den Listenwert. Aber dann haben wir eine if-Schleife, die nach einer Zahl sucht, die gleich 3 ist, und sobald 3 gefunden wird, versucht sie, die Zahl zu entfernen, und hier tritt die Ausnahme auf und das Programm wird beendet. Es wird keine weiteren Ergänzungen zur Liste geben.
Wenn Sie den obigen Code ohne Fehler ausführen, stößt der Code auf eine Ausnahme. Diese Ausnahme liegt bei ConcurrentModificationException.main ( ConcurrentModificationException.java:14). Der Grund für diese Ausnahme ist klar, dass wir versucht haben, eine Liste, Numberlist, zu ändern. Die korrekte Ausgabe finden Sie im unten angehängten Screenshot:
Wie Sie sehen können, wurde das Programm wie beabsichtigt ausgeführt, die Druckanweisungen wurden erfolgreich ausgeführt, bis sie den Wert 3 erreichten. Der Programmfluss wurde beim Wert 3 unterbrochen, weil wir eine if-Schleife hatten, die aussieht für einen Wert, der gleich drei ist, und löscht ihn. Aber der Iterator ist bereits in Bearbeitung und der Versuch, die 3 zu löschen, schlägt fehl und dies löst die Ausnahme ConcurrentModificationException aus.
Für das zweite Beispiel werden wir versuchen, ein Programm auszuführen, das die Concurrent Modification Exception erfolgreich umgeht. Wenn wir im selben Code versuchen, die Array-Liste während des Prozesses zu ändern, wird die ConcurrentModificationException abgefangen und das Programm wird beendet. Der Code für das zweite Beispiel lautet wie folgt:
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.
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.
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.
Das obige ist der detaillierte Inhalt vonJava ConcurrentModificationException. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
