¿Cómo crear un ConcurrentHashSet seguro para subprocesos en Java?

No es posible crear Thread Safe ConcurrentHashSet antes de JDK 8 debido a que el paquete java.util.concurrent no tiene una clase llamada ConcurrentHashSet, pero a partir de JDK 8, los métodos keySet (predeterminado) y newKeySet() recién agregados para crear un ConcurrentHashSet en Java que es compatible con ConcurrentHashMap.

ConcurrentHashSet se puede crear usando ConcurrentHashMap , ya que nos permite usar los métodos keySet (valor predeterminado) y newKeySet() para devolver el Conjunto, que resulta ser un Conjunto adecuado. Esto nos da acceso a las funciones necesarias como contains(), remove(), etc. Estos métodos solo se pueden usar en la clase ConcurrentHashMap y no en la interfaz ConcurrentMap, por lo que necesitamos usar la variable de referencia ConcurrentHashMap para contener la referencia, o podemos usar una conversión de tipo para convertir el objeto ConcurrentHashMap almacenado en la variable ConcurrentMap.

El problema con este método es que solo hay un mapa y ningún conjunto, y no puede realizar una operación de conjunto en ConcurrentHashMap utilizando valores virtuales. Cuando algunos métodos requieren un Conjunto, no puede pasarlo, por lo que no es muy útil.

Otra opción es llamando al método keySet() y el método keySet() en realidad devuelve un Set, en el que la operación Set se puede ejecutar y pasar, pero este método tiene sus limitaciones, ya que no podemos agregar nuevos elementos a este conjunto de claves porque arrojará una excepción de operación no admitida.

Debido a todas estas limitaciones, se introdujo el método newKeySet() que devuelve un conjunto compatible con un tipo dado de ConcurrentHashMap, donde el valor es booleano.

Cómo crear ConcurrentHashSet usando newKeyset():

// Create the ConcurrentHashMap
ConcurrentHashMap<String, Integer> map
    = new ConcurrentHashMap<>();
 
// Create the set by newKeySet() method of ConcurrentHashMap
Set<String> set = map.newKeySet();
 
// add() method
set.add("geeksforgeeks");
set.add("geeks");
 
// contains() method to check whether the element present or
// not it will return boolean value (true or false)
set.contains("geeks");
 
// remove() method to remove an element from set
set.remove("geeksforgeeks");

Este ejemplo mencionado anteriormente no es la única forma de crear un conjunto seguro para subprocesos en Java.

ConcurrentHashSet usando keySet (valor predeterminado):
 

// Create ConcurrentHashMap
ConcurrentHashMap<String, Integer> map
    = new ConcurrentHashMap<>();
 
// Create Set using the map
Set<String> set
    = map.keySet(246); // 246 is any default value
 
set.add("GeeksForGeeks"); // Value will remain same as 246
                          // but we will get no error.
 
// We can use all the functions like contains(),remove(),etc.
// as discussed in the previous code snippet

// Create ConcurrentHashMap
ConcurrentHashMap<String, Integer> map
    = new ConcurrentHashMap<>();
 
// Create Set using the map
Set<String> set
    = map.keySet(246); // 246 is any default value
 
set.add("GeeksForGeeks"); // Value will remain same as 246
                          // but we will ge no error.
 
// We can use all the functions like contains(),remove(),etc.
// as discussed in the previous code snippet

Implementación:

// Java program to implement thread safe ConcurrentHashSet
 
import java.io.*;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
 
class GFG {
    public static void main (String[] args) {
       
        // Creating a map 
        ConcurrentHashMap<String,Integer> map = new ConcurrentHashMap<>();
       
          map.put("Geeks",246);
          map.put("GeeksforGeeks",246);
          map.put("Java", 200);
          map.put("Java 8",200);
          map.put("Threads", 300);
           
          // Creating set using keySet()
          Set concSet = map.keySet();
       
          System.out.println("Initial set: " + concSet);
           
          // If we want to add element is the set like
          // concSet.add("Element"); this will throw an UnsupportedOperationExcetpion
         
          // Now as mentioned in the above format we have to
        // create the set using newKeySet()
          Set <String> penNameSet = ConcurrentHashMap.newKeySet();
         
        penNameSet.add("Flair");
        penNameSet.add("Reynolds");
        penNameSet.add("Cello");
       
          // Print the set
          System.out.println("before adding element into concurrent set: " + penNameSet);
       
          // Adding new Element in the set
          penNameSet.add("Classmate");
           
          // Print again to see the change
          System.out.println("after adding element into concurrent set: " + penNameSet);
           
          // Check element present or not
          if(penNameSet.contains("Reynolds"))
        {
          System.out.println("YES");
        }
          else
        {
          System.out.println("NO");
        }
           
          // We can check directly like this and it will return a boolean value
          System.out.println(penNameSet.contains("Reynolds"));
       
          // Remove any element from set
          penNameSet.remove("Cello");
          System.out.println("after removing element from concurrent set: "
                                    + penNameSet);
       
    }
}

Initial set: [Threads, Java, GeeksforGeeks, Geeks, Java 8]
before adding element into concurrent set: [Cello, Reynolds, Flair]
after adding element into concurrent set: [Cello, Classmate, Reynolds, Flair]
YES
true
after removing element from concurrent set: [Classmate, Reynolds, Flair]

Estos son los métodos para crear ConcurrentHashSet en Java 8. La API de JDK 8 tiene todas las funciones principales, como la expresión lambda y flujos junto con estos pequeños cambios que facilitan la escritura de código.

Las siguientes son algunas propiedades importantes de CopyOnWriteArraySet:

• Es más adecuado para aplicaciones muy pequeñas, la cantidad de operaciones de solo lectura supera con creces las operaciones variables y es necesario evitar la interferencia entre subprocesos durante el recorrido.
• Su hilo es seguro.
• Los rásteres no admiten operaciones de eliminación de variables.
• El recorrido a través del iterador es rápido y no encuentra interferencias de otros subprocesos.
• Los raptores pueden mantener una instantánea de la array sin cambios al construir el iterador.