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

ConcurrentModificationException es una excepción predefinida en Java, que ocurre mientras usamos Java Collections, es decir, cada vez que intentamos modificar un objeto al mismo tiempo sin permiso, ocurre ConcurrentModificationException, que está presente en el paquete java.util .

Procedimiento: se requieren algunos pasos para evitar que ocurra esta excepción en un entorno de subproceso único. Son los siguientes:

• En lugar de iterar a través de las clases de colecciones , podemos iterar a través de las arrays. Esto funciona perfectamente bien para listas más pequeñas, ¿qué pasa con la lista más grande? Es muy básico, sabemos que si el tamaño de la array es enorme, entonces afecta el rendimiento. Por lo tanto, este método solo es efectivo para arrays de menor tamaño.
• El siguiente método es el método de bloque sincronizado . Aquí bloqueamos la lista en un bloque sincronizado para evitar la excepción. ¿No es genial? pero supongo que esto tampoco es un método efectivo para evitar la excepción ¿Por qué? Porque no se está utilizando el propósito de subprocesos múltiples.
• La mejor manera es que tenemos ConcurrentHashMap y CopyOnWriteArrayList, que es el mejor entre los métodos anteriores.

Métodos:

Aquí se proponen dos caminos de los cuales comenzando con el ingenuo y terminando con el enfoque óptimo para alcanzar la meta.

1. Uso de bucles: usamos el método Iterator remove() en lugar de eso, podemos usar un bucle for para evitar ConcurrentModificationException en un entorno de subproceso único. Si agregamos objetos adicionales, podemos asegurarnos de que nuestro código los cuide.
2. Usando el método remove(): podemos usar el método remove para eliminar el objeto de la colección. Aquí hay un problema que es que solo puede eliminar el mismo objeto y no cualquier otro de la lista

Ejemplo 1:

// Java Program to Avoid
// AvoidConcurrentModificationException
 
// Importing Map and List utility classes
//  from java.util package
import java.util.List;
import java.util.Map;
 
// Importing classes from java.util.concurrent package
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an object of List class
        // Declaring object of string type
        List<String> marvel
            = new CopyOnWriteArrayList<String>();
 
        // Adding elements to the above object created
        // Custom input entries
        marvel.add("IronMan");
        marvel.add("BlackWidow");
        marvel.add("Hulk");
        marvel.add("DoctorStrange");
        marvel.add("SpiderMan");
 
        // Iterating over object created using size() method
        for (int i = 0; i < marvel.size(); i++) {
 
            // Print and display the object elements
            // using get() method
            System.out.println("Avenger : "
                               + marvel.get(i));
 
            // Condition check over object elements
 
            // If specific element is matched
            if (marvel.get(i).equals("BlackWidow")) {
 
                marvel.remove(i);
                i--;
 
                // Add this specific element
                marvel.add("CaptianAmerica");
            }
        }
 
        // Now getting the final total size by checking
        // how many elements are there inside object
        System.out.println("Total Avengers : "
                           + marvel.size());
    }
}

Avenger : IronMan
Avenger : BlackWidow
Avenger : Hulk
Avenger : DoctorStrange
Avenger : SpiderMan
Avenger : CaptianAmerica
Total Avengers :5

Nota: La Excepción también puede ocurrir si tratamos de modificar la estructura de la lista original con una sublista. A continuación se muestra un ejemplo de lo mismo,

Ejemplo 2:

// Java Program to Illustrate ConcurrentModificationException
// WithArrayListSubList
 
// Importing List and Arraylist classes utility classes
// from java.util package
import java.util.ArrayList;
import java.util.List;
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args) {
 
        // Creating a List class object
        // Declaring object of string type
        List <String> names = new ArrayList <>();
 
        // Adding elements to the object of List class
 
        // Custom input entries
        names.add("Java");
        names.add("C++");
        names.add("Phython");
        names.add("JavaScript");
 
        List < String > first2Names = names.subList(0, 2);
 
        System.out.println(names + " , " + first2Names);
 
        names.set(1, "Ruby");
 
        // check the output below. 🙂
        System.out.println(names + " , " + first2Names);
 
        // Now we add another string to
        // get ConcurrentModificationException
        names.add("SQL");
 
        // This line throws an exception
        System.out.println(names + " , " + first2Names);
 
    }
}

Producción:

De ahora en adelante, hemos discutido cómo evitar la excepción en entornos de subproceso único y multiproceso con éxito, como se muestra en los resultados anteriores.