Por que não há ConcurrentHashSet contra ConcurrentHashMap

O HashSet é baseado no HashMap.

Se observarmos a HashSet<E>implementação, tudo será gerenciado HashMap<E,Object>.

<E>é usado como uma chave de HashMap.

E sabemos que isso HashMapnão é seguro para threads. É por isso que temos ConcurrentHashMapem Java.

Com base nisso, estou confuso de que por que não temos um ConcurrentHashSet que deve ser baseado no ConcurrentHashMap?

Falta mais alguma coisa? Eu preciso usar Setem um ambiente multiencadeado.

Além disso, se eu quiser criar o meu próprio, ConcurrentHashSetposso consegui-lo apenas substituindo o HashMappara ConcurrentHashMape deixando o resto como está?

Não existe um tipo incorporado ConcurrentHashSetporque você sempre pode derivar um conjunto de um mapa. Como existem muitos tipos de mapas, você usa um método para produzir um conjunto a partir de um determinado mapa (ou classe de mapa).

Antes do Java 8, você produz um conjunto de hash simultâneo apoiado por um mapa de hash simultâneo, usando Collections.newSetFromMap(map)

No Java 8 (apontado por @Matt), você pode obter uma visualização simultânea de conjunto de hash via ConcurrentHashMap.newKeySet(). Isso é um pouco mais simples que o antigo, newSetFromMapque exigia que você passasse um objeto de mapa vazio. Mas é específico para ConcurrentHashMap.

De qualquer forma, os designers de Java poderiam ter criado uma nova interface de conjunto toda vez que uma nova interface de mapa fosse criada, mas esse padrão seria impossível de aplicar quando terceiros criam seus próprios mapas. É melhor ter os métodos estáticos que derivam novos conjuntos; essa abordagem sempre funciona, mesmo quando você cria suas próprias implementações de mapas.

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

Com o Guava 15 você também pode simplesmente usar:

Set s = Sets.newConcurrentHashSet();

Como Ray Toal mencionou, é tão fácil quanto:

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

Parece que o Java fornece uma implementação simultânea do conjunto com seu ConcurrentSkipListSet . Um conjunto SkipList é apenas um tipo especial de implementação de conjunto. Ele ainda implementa as interfaces Serializable, Cloneable, Iterable, Collection, NavigableSet, Set, SortedSet. Isso pode funcionar para você se você precisar apenas da interface Set.

Como apontado por isso a melhor maneira de obter um HashSet simultaneidade capaz é por meio deCollections.synchronizedSet()

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

Isso funcionou para mim e eu não vi ninguém realmente apontando para isso.

EDIT Isso é menos eficiente do que a solução atualmente aprovada, como Eugene aponta, uma vez que apenas envolve seu conjunto em um decorador sincronizado, enquanto um ConcurrentHashMapimplementa a simultaneidade de baixo nível e pode fazer o seu conjunto da mesma maneira. Então, obrigado ao Sr. Stepanenkov por deixar isso claro.

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

Você pode usar goiabas Sets.newSetFromMap(map)para obter uma. O Java 6 também possui esse método emjava.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 que não usar: CopyOnWriteArraySet de java.util.concurrent?