Dlaczego nie ma ConcurrentHashSet przeciwko ConcurrentHashMap

HashSet jest oparty na HashMap.

Jeśli spojrzymy na HashSet<E>implementację, wszystko jest zarządzane w ramach HashMap<E,Object>.

<E>jest używany jako klucz HashMap.

I wiemy, że HashMapnie jest to bezpieczne dla wątków. Właśnie dlatego mamy ConcurrentHashMapJavę.

Na tej podstawie jestem zdezorientowany, dlaczego nie mamy ConcurrentHashSet, który powinien być oparty na ConcurrentHashMap?

Czy coś jeszcze mi brakuje? Muszę używać Setw środowisku wielowątkowym.

Ponadto, jeśli chcę stworzyć własny, ConcurrentHashSetczy mogę to osiągnąć, po prostu zastępując HashMapgo ConcurrentHashMapi pozostawiając resztę bez zmian?

Nie ma wbudowanego typu, ConcurrentHashSetponieważ zawsze możesz uzyskać zestaw z mapy. Ponieważ istnieje wiele rodzajów map, używasz metody do utworzenia zestawu z danej mapy (lub klasy mapy).

Przed wersją Java 8 tworzysz współbieżny zestaw skrótów wsparty współbieżną mapą skrótu, używając Collections.newSetFromMap(map)

W Javie 8 (wskazanej przez @Matt) można uzyskać widok współbieżnego zestawu skrótów za pośrednictwem ConcurrentHashMap.newKeySet(). Jest to nieco prostsze niż stare, newSetFromMapktóre wymagało przejścia przez pusty obiekt mapy. Ale jest specyficzny dla ConcurrentHashMap.

W każdym razie projektanci Java mogli stworzyć nowy zestaw interfejsów za każdym razem, gdy tworzony był nowy interfejs mapy, ale wzorzec ten byłby niemożliwy do narzucenia, gdy osoby trzecie utworzyły własne mapy. Lepiej jest mieć metody statyczne, które wyprowadzają nowe zbiory; takie podejście zawsze działa, nawet gdy tworzysz własne implementacje map.

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

Z Guava 15 możesz także po prostu użyć:

Set s = Sets.newConcurrentHashSet();

Jak wspomniał Ray Toal, jest to tak proste, jak:

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

Wygląda na to, że Java zapewnia współbieżną implementację zestawu z jego ConcurrentSkipListSet . SkipList Set to tylko szczególny rodzaj zadanej realizacji. Nadal implementuje interfejsy Serializable, Cloneable, Iterable, Collection, NavigableSet, Set, SortedSet. Może to działać dla Ciebie, jeśli potrzebujesz tylko interfejsu Set.

Jak wskazano przez to najlepszy sposób uzyskania współbieżności-stanie HashSet jest za pomocąCollections.synchronizedSet()

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

To działało dla mnie i nie widziałem nikogo, kto by na to naprawdę wskazywał.

EDYCJA Jest to mniej wydajne niż obecnie zatwierdzone rozwiązanie, jak zauważa Eugene, ponieważ po prostu owija Twój zestaw w zsynchronizowany dekorator, podczas gdy w ConcurrentHashMaprzeczywistości implementuje współbieżność niskiego poziomu i może wesprzeć Twój zestaw równie dobrze. Dziękuję panu Stepanenkovowi za wyjaśnienie.

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

Możesz użyć guawy, Sets.newSetFromMap(map)aby go zdobyć. Java 6 ma również tę metodę wjava.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;
   }
}

Dlaczego nie użyć: CopyOnWriteArraySet z java.util.concurrent?