Pourquoi il n’y a aucun ConcurrentHashSet contre ConcurrentHashMap

Question

HashSet est basé sur la table de hachage.

Si l'on regarde HashSet<E> mise en œuvre, tout est géré en vertu de l' HashMap<E,Object>.

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

Et nous savons qu' HashMap n'est pas thread-safe. C'est pourquoi nous avons ConcurrentHashMap en Java.

Sur cette base, je suis confus que pourquoi nous n'avons pas ConcurrentHashSet qui doit être basé sur l' ConcurrentHashMap?

Est-il autre chose que je suis absent? J'ai besoin d'utiliser Set dans un environnement multi-thread.

Aussi, Si je veux créer mon propre ConcurrentHashSet puis-je obtenir seulement par le remplacement de l' HashMap de ConcurrentHashMap et en laissant le reste?

Answer 1

Vous pouvez trivialement produire une concurrente de hachage ensemble soutenu par une concurrente de hachage de la carte, en utilisant newSetFromMap, a expliqué dans le détail http://download.oracle.com/javase/6/docs/api/java/util/Collections.html#newSetFromMap(java.util.Map)

Je soupçonne que les concepteurs de l'API estimé que le fait de fournir une méthode (statique) pour produire un jeu basé sur toute la carte a été mieux que la création d'une nouvelle interface à chaque fois qu'une nouvelle carte d'interface a été ajoutée. Cela dit, il ne se sent quelque peu maladroit que vous avez à créer un vide carte pour passer à cette méthode, n'est-ce pas?

Answer 2

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

Answer 3

Il ressemble à Java fournit une implémentation Set simultanée avec son ConcurrentSkipListSet. Un Jeu de SkipList est juste un type spécial d’implémentation définie. Il implémente toujours la Serializable, Cloneable, Iterable, Collection, NavigableSet, ensemble, SortedSet interfaces. Cela pourrait fonctionner pour vous, si vous avez seulement besoin de l’interface de jeu.

Answer 4

Vous pouvez utiliser de goyave `` pour en obtenir un. Java 6 a également cette méthode``

Answer 5

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;
   }

}