Pourquoi il n'y a pas de ConcurrentHashSet contre ConcurrentHashMap

HashSet est basé sur HashMap.

Si nous regardons la HashSet<E>mise en œuvre, tout est géré sous HashMap<E,Object>.

<E>est utilisé comme clé de HashMap.

Et nous savons que ce HashMapn'est pas sûr pour les threads. C'est pourquoi nous avons ConcurrentHashMapen Java.

Sur cette base, je ne comprends pas pourquoi nous n'avons pas de ConcurrentHashSet qui devrait être basé sur le ConcurrentHashMap?

Y a-t-il autre chose qui me manque? Je dois utiliser Setdans un environnement multi-thread.

De plus, si je veux créer le mien, ConcurrentHashSetpuis-je le réaliser en remplaçant simplement le HashMapto ConcurrentHashMapet en laissant le reste tel quel?

Il n'y a pas de type intégré ConcurrentHashSetcar vous pouvez toujours dériver un ensemble d'une carte. Comme il existe de nombreux types de cartes, vous utilisez une méthode pour produire un ensemble à partir d'une carte (ou classe de carte) donnée.

Avant Java 8, vous produisez un ensemble de hachage simultané soutenu par une carte de hachage simultanée, en utilisant Collections.newSetFromMap(map)

Dans Java 8 (souligné par @Matt), vous pouvez obtenir une vue d' ensemble de hachage simultanée via ConcurrentHashMap.newKeySet(). C'est un peu plus simple que l'ancien newSetFromMapqui vous obligeait à passer dans un objet de carte vide. Mais c'est spécifique à ConcurrentHashMap.

Quoi qu'il en soit, les concepteurs Java auraient pu créer une nouvelle interface d'ensemble à chaque fois qu'une nouvelle interface de carte était créée, mais ce modèle serait impossible à appliquer lorsque des tiers créeraient leurs propres cartes. Il est préférable d'avoir les méthodes statiques qui dérivent de nouveaux ensembles; cette approche fonctionne toujours, même lorsque vous créez vos propres implémentations de carte.

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

Avec Guava 15, vous pouvez également simplement utiliser:

Set s = Sets.newConcurrentHashSet();

Comme Ray Toal l'a mentionné, c'est aussi simple que:

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

Il semble que Java fournisse une implémentation Set simultanée avec son ConcurrentSkipListSet . Un ensemble SkipList n'est qu'un type spécial d'implémentation d'ensemble. Il implémente toujours les interfaces Serializable, Cloneable, Iterable, Collection, NavigableSet, Set, SortedSet. Cela peut fonctionner pour vous si vous n'avez besoin que de l'interface Set.

Comme indiqué par cela, le meilleur moyen d'obtenir un HashSet compatible avec la concurrence est deCollections.synchronizedSet()

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

Cela a fonctionné pour moi et je n'ai vu personne le montrer du doigt.

EDITER Ceci est moins efficace que la solution actuellement approuvée, comme le souligne Eugene, car elle enveloppe simplement votre ensemble dans un décorateur synchronisé, tandis qu'un ConcurrentHashMapimplémente en fait une concurrence de bas niveau et peut sauvegarder votre ensemble tout aussi bien. Merci donc à M. Stepanenkov de l'avoir précisé.

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

Vous pouvez utiliser des goyaves pour Sets.newSetFromMap(map)en obtenir un. Java 6 a également cette méthode dansjava.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;
   }
}

Pourquoi ne pas utiliser: CopyOnWriteArraySet de java.util.concurrent?