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():
Java
// 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):
Java
// 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
Java
// 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
// 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.
Publicación traducida automáticamente
Artículo escrito por TanmayChakraborty y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA