Por qué no hay ConcurrentHashSet contra ConcurrentHashMap

HashSet se basa en HashMap.

Si nos fijamos en la HashSet<E>implementación, todo se gestiona bajo HashMap<E,Object>.

<E>se usa como clave de HashMap.

Y sabemos que HashMapno es seguro para subprocesos. Por eso tenemos ConcurrentHashMapen Java.

En base a esto, estoy confundido porque no tenemos un ConcurrentHashSet que debería basarse en el ConcurrentHashMap?

¿Hay algo más que me estoy perdiendo? Necesito usar Seten un entorno multiproceso.

Además, si quiero crear el mío, ConcurrentHashSet¿puedo lograrlo simplemente reemplazando el HashMapto ConcurrentHashMapy dejando el resto como está?

No hay un tipo incorporado ConcurrentHashSetporque siempre puedes derivar un conjunto de un mapa. Como hay muchos tipos de mapas, utiliza un método para producir un conjunto a partir de un mapa determinado (o clase de mapa).

Antes de Java 8, produce un conjunto de hash simultáneo respaldado por un mapa de hash simultáneo, mediante el uso de Collections.newSetFromMap(map)

En Java 8 (señalado por @Matt), puede obtener una vista de conjunto de hash simultáneo a través de ConcurrentHashMap.newKeySet(). Esto es un poco más simple que el anterior newSetFromMapque requería que pasaras un objeto de mapa vacío. Pero es específico de ConcurrentHashMap.

De todos modos, los diseñadores de Java podrían haber creado una nueva interfaz de conjunto cada vez que se creó una nueva interfaz de mapa, pero ese patrón sería imposible de aplicar cuando terceros creen sus propios mapas. Es mejor tener los métodos estáticos que derivan nuevos conjuntos; ese enfoque siempre funciona, incluso cuando crea sus propias implementaciones de mapas.

Set<String> mySet = Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>());

Con Guava 15 también puedes usar simplemente:

Set s = Sets.newConcurrentHashSet();

Como Ray Toal mencionó, es tan fácil como:

Set<String> myConcurrentSet = ConcurrentHashMap.newKeySet();

Parece que Java proporciona una implementación de conjunto concurrente con su ConcurrentSkipListSet . Un conjunto SkipList es solo un tipo especial de implementación de conjunto. Todavía implementa las interfaces Serializable, Cloneable, Iterable, Collection, NavigableSet, Set, SortedSet. Esto podría funcionar para usted si solo necesita la interfaz Set.

Como se ha señalado por esta la mejor manera de obtener un HashSet concurrencia-poder es por medio deCollections.synchronizedSet()

Set s = Collections.synchronizedSet(new HashSet(...));

Esto funcionó para mí y no he visto a nadie realmente señalando.

EDITAR Esto es menos eficiente que la solución aprobada actualmente, como señala Eugene, ya que simplemente envuelve su conjunto en un decorador sincronizado, mientras que en ConcurrentHashMaprealidad implementa una concurrencia de bajo nivel y puede respaldar su Conjunto igual de bien. Así que gracias al Sr. Stepanenkov por dejar eso claro.

http://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#synchronizedSet-java.util.Set-

Puedes usar guayabas Sets.newSetFromMap(map)para conseguir uno. Java 6 también tiene ese método enjava.util.Collections

import java.util.AbstractSet;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;


public class ConcurrentHashSet<E> extends AbstractSet<E> implements Set<E>{
   private final ConcurrentMap<E, Object> theMap;

   private static final Object dummy = new Object();

   public ConcurrentHashSet(){
      theMap = new ConcurrentHashMap<E, Object>();
   }

   @Override
   public int size() {
      return theMap.size();
   }

   @Override
   public Iterator<E> iterator(){
      return theMap.keySet().iterator();
   }

   @Override
   public boolean isEmpty(){
      return theMap.isEmpty();
   }

   @Override
   public boolean add(final E o){
      return theMap.put(o, ConcurrentHashSet.dummy) == null;
   }

   @Override
   public boolean contains(final Object o){
      return theMap.containsKey(o);
   }

   @Override
   public void clear(){
      theMap.clear();
   }

   @Override
   public boolean remove(final Object o){
      return theMap.remove(o) == ConcurrentHashSet.dummy;
   }

   public boolean addIfAbsent(final E o){
      Object obj = theMap.putIfAbsent(o, ConcurrentHashSet.dummy);
      return obj == null;
   }
}

¿Por qué no usar: CopyOnWriteArraySet de java.util.concurrent?