¿Cómo resolver la excepción ConcurrentModificationException en Java?

Un evento no deseado no aceptado que interrumpe el flujo normal de un programa se denomina excepción . La mayoría de las excepciones son causadas por nuestro programa y son recuperables. Ejemplo: si el requisito de nuestro programa es leer datos del archivo remoto ubicado en los EE. UU. En tiempo de ejecución, si un archivo remoto no está disponible, obtendremos RuntimeException diciendo FileNotFoundException . Si se produce la excepción FileNotFoundException, podemos proporcionar el archivo local al programa para que lea y continúe con el resto del programa normalmente.

Hay principalmente dos tipos de excepción  en Java de la siguiente manera:

1. Las excepciones verificadas son las excepciones que el compilador verifica para la ejecución sin problemas del programa en tiempo de ejecución y se denominan excepciones verificadas. En nuestro programa, si existe la posibilidad de que aumenten las excepciones verificadas, entonces es obligatorio que manejemos esa excepción verificada (ya sea mediante la palabra clave try-catch o throws); de lo contrario, obtendremos un error en tiempo de compilación.
2. Las excepciones no verificadas son las excepciones que no son verificadas por el compilador, ya sea que el programador las maneje o no, estos tipos de excepciones se denominan excepciones no verificadas. Ejemplos de excepciones no verificadas son ArithmeticException , ArrayStoreException , etc.

Nota: Ya sea que la excepción esté marcada o no, cada excepción ocurre en tiempo de ejecución solo si no hay posibilidad de que ocurra ninguna excepción en tiempo de compilación.

 Implementación:

ConcurrentModificationException es la clase secundaria de RuntimeException y, por lo tanto, es una excepción no verificada. Esta excepción surge cuando se intenta modificar un objeto simultáneamente cuando no está permitido, es decir, cuando un subproceso está iterando sobre algún objeto de clase de colección y si algún otro subproceso intentó modificar o intentar hacer algunos cambios en ese objeto de colección, entonces obtendremos Excepción de modificación simultánea. Esta excepción suele ocurrir cuando estamos trabajando con clases de colecciones de Java.

Ejemplo

// Java program to illustrate
// ConcurrentModificationException
 
// Importing all classes from java.util package
// Importing input output classes
import java.io.*;
import java.util.*;
 
// Main Class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an object of ArrayList
        // Declaring object of Integer type
        ArrayList<Integer> list = new ArrayList<>();
 
        // Adding element to ArrayList object created above
        // using the add() method
        // Custom input elements
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
 
        // Display all the elements of ArrayList object
        System.out.println("List Value Before Iteration:"
                           + list);
 
        // Creating an iterator object to
        // iterate over the ArrayList
        Iterator<Integer> it = list.iterator();
 
        // Condition check
        // It holds true till there is single element
        // remaining in the List
        while (it.hasNext()) {
            Integer value = it.next();
 
            // Here we are trying to remove the one entry of
            // ArrayList base on the if condition and hence
 
            // We will get Concurrent ModificationException
            if (value.equals(3))
                list.remove(value);
        }
 
        // Print and display the value of ArrayList object
        System.out.println("List Value After Iteration:"
                           + list);
    }
}

Producción:

Explicación de salida:

El programa anterior es un programa de subproceso único y aquí podemos evitar ConcurrentModificationException mediante el uso de la función remove() del iterador, podemos eliminar un objeto de un objeto de colección subyacente sin obtener ninguna excepción.

Ejemplo 2  

// Java Program to illustrate
// ConcurrentModificationException
 
// Importing the required packages
import java.io.*;
import java.util.*;
import java.util.Iterator;
 
// Main Class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an collection class object
        // Declaring object of integer type
        ArrayList<Integer> list = new ArrayList<>();
 
        // Adding element to ArrayList
        // using add() method
 
        // Custom integer input entries
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
 
        // Display the value of ArrayList
        System.out.println("List Value Before Iteration:"
                           + list);
 
        // Creating an iterator object
        // to iterate over the ArrayList
        Iterator<Integer> itr = list.iterator();
 
        // Condition check
        // it holds true till there is single element
        // remaining in the List
        while (itr.hasNext()) {
 
            // next() method() looks out for next element in
            // the List
            Integer value = itr.next();
 
            // Here we are trying to remove the one entry of
            // ArrayList base on the given if condition and
            // hence
 
            // We will get Concurrent ModificationException
            if (value.equals(3))
                itr.remove();
        }
        // Display the value of ArrayList
        System.out.println("List Value After iteration:"
                           + list);
    }
}

List Value Before Iteration:[1, 2, 3, 4, 5]
List Value After iteration:[1, 2, 4, 5]

Nota: en un programa de subprocesos múltiples, podemos evitar ConcurrentModificaionException mediante el uso de   las clases ConcurrentHashMap y CopyOnWriteArrayList . Estas clases nos ayudan a evitar ConcurrentModificaionException.