Perché non esiste ConcurrentHashSet contro ConcurrentHashMap

HashSet si basa su HashMap.

Se guardiamo HashSet<E>all'implementazione, tutto è gestito sotto HashMap<E,Object>.

<E>è usato come chiave di HashMap.

E sappiamo che HashMapnon è thread-safe. Ecco perché abbiamo ConcurrentHashMapin Java.

Sulla base di questo, sono confuso dal fatto che non abbiamo un ConcurrentHashSet che dovrebbe essere basato sul ConcurrentHashMap?

C'è qualcos'altro che mi manca? Devo usare Setin un ambiente multi-thread.

Inoltre, se voglio crearne uno mio ConcurrentHashSetposso ottenerlo semplicemente sostituendo il HashMapto ConcurrentHashMape lasciando il resto com'è?

Non esiste un tipo incorporato per ConcurrentHashSetperché puoi sempre derivare un set da una mappa. Poiché esistono molti tipi di mappe, si utilizza un metodo per produrre un set da una determinata mappa (o classe di mappe).

Prima di Java 8, si produce un set di hash simultaneo supportato da una mappa di hash simultanea, usando Collections.newSetFromMap(map)

In Java 8 (sottolineato da @Matt), è possibile ottenere una vista insieme di hash simultanea tramite ConcurrentHashMap.newKeySet(). Questo è un po 'più semplice rispetto al vecchio newSetFromMapche richiedeva il passaggio in un oggetto cartografico vuoto. Ma è specifico per ConcurrentHashMap.

In ogni caso, i progettisti Java avrebbero potuto creare una nuova interfaccia set ogni volta che veniva creata una nuova interfaccia mappa, ma tale modello sarebbe impossibile da applicare quando terze parti creano le proprie mappe. È meglio avere i metodi statici che derivano nuovi set; tale approccio funziona sempre, anche quando crei le tue implementazioni di mappe.

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

Con Guava 15 puoi anche semplicemente usare:

Set s = Sets.newConcurrentHashSet();

Come ha detto Ray Toal , è facile come:

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

Sembra che Java fornisca un'implementazione di Set simultanea con il suo ConcurrentSkipListSet . Un set SkipList è solo un tipo speciale di implementazione del set. Implementa ancora le interfacce Serializable, Cloneable, Iterable, Collection, NavigableSet, Set, SortedSet. Questo potrebbe funzionare per te se hai solo bisogno dell'interfaccia Set.

Come indicato da questo, il modo migliore per ottenere un HashSet in grado di competere è tramiteCollections.synchronizedSet()

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

Questo ha funzionato per me e non ho visto nessuno davvero indicarlo.

EDIT Questo è meno efficiente della soluzione attualmente approvata, come sottolinea Eugene, dal momento che avvolge il tuo set in un decoratore sincronizzato, mentre in ConcurrentHashMaprealtà implementa una concorrenza di basso livello e può supportare il tuo Set altrettanto bene. Quindi grazie a Mr. Stepanenkov per averlo chiarito.

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

Puoi usare guava Sets.newSetFromMap(map)per ottenerne uno. Anche Java 6 ha questo metodojava.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;
   }
}

Perché non usare: CopyOnWriteArraySet da java.util.concurrent?