CopyOnWriteArrayList en Java

La clase CopyOnWriteArrayList se introduce en JDK 1.5, que implementa la interfaz List . Es una versión mejorada de ArrayList en la que todas las modificaciones (agregar, establecer, eliminar, etc.) se implementan haciendo una copia nueva. Se encuentra en el paquete java.util.concurrent . Es una estructura de datos creada para ser utilizada en un entorno concurrente.
 

Aquí hay algunos puntos sobre CopyOnWriteArrayList: 

• Como su nombre lo indica, CopyOnWriteArrayList crea una copia clonada de ArrayList subyacente, para cada operación de actualización en un punto determinado, ambas se sincronizarán automáticamente, de lo cual se encargará JVM. Por lo tanto, no hay ningún efecto para los subprocesos que realizan operaciones de lectura.
• Su uso es costoso porque por cada operación de actualización se creará una copia clonada. Por lo tanto, CopyOnWriteArrayList es la mejor opción si nuestra operación frecuente es la operación de lectura.
• La estructura de datos subrayada es una array capaz de crecer.
• Es una versión segura para subprocesos de ArrayList.
• Se conserva la inserción, se permiten objetos duplicados, nulos y heterogéneos.
• El principal punto importante sobre CopyOnWriteArrayList es que el iterador de CopyOnWriteArrayList no puede realizar la operación de eliminación; de lo contrario, obtenemos una excepción en tiempo de ejecución que dice UnsupportedOperationException. Los métodos add() y set() en el iterador CopyOnWriteArrayList también lanzan UnsupportedOperationException. Además, el iterador de CopyOnWriteArrayList nunca lanzará ConcurrentModificationException .

Declaración:

la clase pública CopyOnWriteArrayList<E> extiende Object implements List<E>, RandomAccess, Cloneable, Serializable

Aquí, E es el tipo de elementos que se encuentran en esta colección.

Nota: La clase implementa las interfaces Serializable , Cloneable , Iterable<E> , Collection<E> , List<E> , RandomAccess .

Constructores:

1. CopyOnWriteArrayList() : crea una lista vacía.

CopyOnWriteArrayList c = new CopyOnWriteArrayList();

2. CopyOnWriteArrayList(Collection obj) : crea una lista que contiene los elementos de la colección especificada, en el orden en que son devueltos por el iterador de la colección.

CopyOnWriteArrayList c = new CopyOnWriteArrayList(Collection obj);

3. CopyOnWriteArrayList(Objeto[] obj); : Crea una lista que contiene una copia de la array dada.

CopyOnWriteArrayList c = new CopyOnWriteArrayList(Object[] obj);

Ejemplo: 

// Java program to illustrate
// CopyOnWriteArrayList class
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
 
public class ConcurrentDemo extends Thread {
 
    static CopyOnWriteArrayList<String> l
        = new CopyOnWriteArrayList<String>();
 
    public void run()
    {
        // Child thread trying to
        // add new element in the
        // Collection object
        l.add("D");
    }
 
    public static void main(String[] args)
        throws InterruptedException
    {
        l.add("A");
        l.add("B");
        l.add("c");
 
        // We create a child thread
        // that is going to modify
        // ArrayList l.
        ConcurrentDemo t = new ConcurrentDemo();
        t.run();
 
        Thread.sleep(1000);
 
        // Now we iterate through
        // the ArrayList and get
        // exception.
        Iterator itr = l.iterator();
        while (itr.hasNext()) {
            String s = (String)itr.next();
            System.out.println(s);
            Thread.sleep(1000);
        }
        System.out.println(l);
    }
}

A
B
c
D
[A, B, c, D]

Iterando sobre CopyOnWriteArrayList: Podemos iterar sobre CopyOnWriteArrayList usando el método iterator() . El punto importante a tener en cuenta es que el iterador que creamos es una instantánea inmutable de la lista original. Debido a esta propiedad, podemos ver que GfG no se imprime en la primera iteración.

// Java program to illustrate
// CopyOnWriteArrayList class
import java.io.*;
import java.util.*;
import java.util.concurrent.*;
 
class Demo {
    public static void main(String[] args)
    {
 
        CopyOnWriteArrayList<String> list
            = new CopyOnWriteArrayList<>();
 
        // Initial Iterator
        Iterator itr = list.iterator();
        list.add("GfG");
        System.out.println("List contains: ");
        while (itr.hasNext())
            System.out.println(itr.next());
 
        // iterator after adding an element
        itr = list.iterator();
        System.out.println("List contains:");
        while (itr.hasNext())
            System.out.println(itr.next());
    }
}

List contains: 
List contains:
GfG

Métodos de CopyOnWriteArrayList:

Métodos heredados de la interfaz java.util.Collection:

Nota: Deberíamos usar CopyOnWriteArrayList cuando preferimos usar una estructura de datos similar a ArrayList en un entorno concurrente.

Debe leer:

• Diferencia entre ArrayList y CopyOnWriteArrayList