CopyOnWriteArraySet en Java

CopyOnWriteArraySet es miembro de Java Collections Framework . Es un conjunto que utiliza un CopyOnWriteArrayList interno para todas sus operaciones. Se introdujo en JDK 1.5, podemos decir que es una versión segura de subprocesos de Set. Para usar esta clase, debemos importarla desde el paquete java.util.concurrent . 

Comparte algunas propiedades de Set y también tiene sus propias propiedades, como se indica:

• La implementación interna de CopyOnWriteArraySet es solo CopyOnWriteArrayList .
• Múltiples subprocesos pueden realizar operaciones de actualización simultáneamente, pero para cada operación de actualización, se crea una copia clonada por separado. Como para cada actualización, se creará una nueva copia clonada, lo cual es costoso. Por lo tanto, si se requieren varias operaciones de actualización, no se recomienda utilizar CopyOnWriteArraySet.
• Mientras un subproceso itera el Conjunto, otros subprocesos pueden realizar la actualización, aquí no obtendremos ninguna excepción de tiempo de ejecución como ConcurrentModificationException .
• Un iterador de la clase CopyOnWriteArraySet solo puede realizar solo lectura y no debe realizar la eliminación; de lo contrario, obtendremos la excepción de tiempo de ejecución UnsupportedOperationException .
• Utilice CopyOnWriteArraySet en aplicaciones en las que los tamaños de los conjuntos suelen ser pequeños, las operaciones de solo lectura superan con creces a las operaciones mutativas y necesita evitar la interferencia entre subprocesos durante el recorrido.
• CopyOnWriteArraySet ayuda a minimizar los pasos de sincronización controlados por el programador y a mover el control a API integradas y bien probadas.

La jerarquía de clases es la siguiente:

java.lang.Object
   ↳ java.util.AbstractCollection<E>
        ↳ java.util.AbstractSet<E>
             ↳ java.util.concurrent.CopyOnWriteArraySet<E>

Sintaxis: Declaración

public class CopyOnWriteArraySet<E> extends AbstractSet<E> implements Serializable

Aquí, E es el tipo de elementos almacenados en esta Colección. Implementa interfaces Serializable , Iterable<E> , Collection<E> , Set<E> .

Constructores de CopyOnWriteArraySet 

1. CopyOnWriteArraySet() : crea un conjunto vacío.

CopyOnWriteArraySet<E> c = new CopyOnWriteArraySet<E>();

2. CopyOnWriteArraySet(Collection c) : crea un conjunto que contiene todos los elementos de la colección especificada.

CopyOnWriteArraySet<E> c = new CopyOnWriteArraySet<E>(Collection c);

Ejemplo:

// Java Program to Illustrate CopyOnWriteArraySet Class
 
// Importing required classes
import java.util.*;
import java.util.concurrent.*;
 
// Main class
class ConcurrentDemo extends Thread {
 
    static CopyOnWriteArraySet l
        = new CopyOnWriteArraySet();
 
    // Method
    public void run()
    {
        // Child thread trying to add
        // new element in the Set object
        l.add("D");
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
 
        // Adding elements
        // using add() method
        l.add("A");
        l.add("B");
        l.add("C");
 
        // We create a child thread
        // that is going to modify
        // CopyOnWriteArraySet l.
        ConcurrentDemo t = new ConcurrentDemo();
 
        // Running the child thread
        // using start() method
        t.start();
 
        // Waiting for the thread to
        // add the element
 
        // Try block to check for exceptions
        try {
 
            Thread.sleep(2000);
        }
 
        // Catch block to handle exceptions
        catch (InterruptedException e) {
 
            // Print statement
            System.out.println(
                "child going to add element");
        }
 
        System.out.println(l);
 
        // Now we iterate through the
        // CopyOnWriteArraySet and we
        // wont get exception.
        Iterator itr = l.iterator();
 
        while (itr.hasNext()) {
 
            String s = (String)itr.next();
            System.out.println(s);
 
            if (s.equals("C")) {
 
                // Here we will get
                // RuntimeException
                itr.remove();
            }
        }
    }
}

 Producción: 

Iterando sobre CopyOnWriteArraySet

Podemos iterar sobre los elementos contenidos en este conjunto en el orden en que estos elementos fueron agregados usando el método iterator() . El iterador devuelto proporciona una instantánea inmutable del estado del conjunto cuando se construyó el iterador. Debido a esta propiedad, GeeksforGeeks no se imprime en la primera iteración. No se requiere sincronización durante la iteración. El iterador no admite el método de eliminación. 

Ejemplo:

// Java program to Illustrate Iterating Over
// CopyOnWriteArraySet class
 
// Importing required classes
import java.io.*;
import java.util.*;
import java.util.concurrent.*;
 
// Main class
// IteratingCopyOnWriteArraySet
class GFG {
 
    // Main class
    public static void main(String[] args)
    {
 
        // Creating an instance of CopyOnWriteArraySet
        CopyOnWriteArraySet<String> set
            = new CopyOnWriteArraySet<>();
 
        // Initial an iterator
        Iterator itr = set.iterator();
 
        // Adding elements
        // using add() method
        set.add("GeeksforGeeks");
 
        // Display message only
        System.out.println("Set contains: ");
 
        // Printing the contents
        // of set to the console
        while (itr.hasNext())
            System.out.println(itr.next());
 
        // Iterator after adding an element
        itr = set.iterator();
 
        // Display message only
        System.out.println("Set contains:");
 
        // Printing the elements to the console
        while (itr.hasNext())
            System.out.println(itr.next());
    }
}

Set contains: 
Set contains:
GeeksforGeeks

 Métodos en CopyOnWriteArraySet

Métodos heredados de la clase java.util.AbstractSet

Métodos heredados de la clase java.util.AbstractCollection

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

HashSet frente a CopyOnWriteArraySet