Warum gibt es kein ConcurrentHashSet gegen ConcurrentHashMap?

HashSet basiert auf HashMap.

Wenn wir uns die HashSet<E>Implementierung ansehen , wird alles unter verwaltet HashMap<E,Object>.

<E>wird als Schlüssel von verwendet HashMap.

Und wir wissen, dass HashMapdas nicht threadsicher ist. Deshalb haben wir ConcurrentHashMapin Java.

Aufgrund dessen bin ich verwirrt, warum wir kein ConcurrentHashSet haben, das auf dem basieren sollte ConcurrentHashMap.

Fehlt mir noch etwas? Ich muss Setin einer Multithread-Umgebung verwenden.

Wenn ich meine eigenen erstellen möchte, ConcurrentHashSetkann ich dies erreichen, indem ich einfach das HashMapto ersetze ConcurrentHashMapund den Rest unverändert lasse?

Es gibt keinen eingebauten Typ für, ConcurrentHashSetda Sie einen Satz immer von einer Karte ableiten können . Da es viele Arten von Karten gibt, verwenden Sie eine Methode, um einen Satz aus einer bestimmten Karte (oder Kartenklasse) zu erstellen.

Vor Java 8 erstellen Sie mithilfe von einen gleichzeitigen Hash-Satz, der von einer gleichzeitigen Hash-Map unterstützt wird Collections.newSetFromMap(map)

In Java 8 (von @Matt hervorgehoben) können Sie eine gleichzeitige Hash-Set- Ansicht über erhalten ConcurrentHashMap.newKeySet(). Dies ist etwas einfacher als das alte, bei newSetFromMapdem Sie ein leeres Kartenobjekt übergeben mussten. Aber es ist spezifisch für ConcurrentHashMap.

Wie auch immer, die Java-Designer hätten jedes Mal, wenn eine neue Kartenschnittstelle erstellt wurde, eine neue Set-Schnittstelle erstellen können, aber dieses Muster wäre unmöglich durchzusetzen, wenn Dritte ihre eigenen Karten erstellen. Es ist besser, die statischen Methoden zu haben, die neue Mengen ableiten. Dieser Ansatz funktioniert immer, auch wenn Sie Ihre eigenen Kartenimplementierungen erstellen.

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

Mit Guava 15 können Sie auch einfach verwenden:

Set s = Sets.newConcurrentHashSet();

Wie Ray Toal erwähnt hat, ist es so einfach wie:

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

Es sieht so aus, als würde Java mit seinem ConcurrentSkipListSet eine gleichzeitige Set-Implementierung bereitstellen . Ein SkipList-Set ist nur eine spezielle Art der Set-Implementierung. Es implementiert weiterhin die Schnittstellen Serializable, Cloneable, Iterable, Collection, NavigableSet, Set und SortedSet. Dies funktioniert möglicherweise für Sie, wenn Sie nur die Set-Schnittstelle benötigen.

Wie hier gezeigt, ist der beste Weg, um ein paralleles HashSet zu erhalten, der überCollections.synchronizedSet()

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

Das hat bei mir funktioniert und ich habe niemanden gesehen, der wirklich darauf hingewiesen hat.

BEARBEITEN Dies ist weniger effizient als die derzeit empfohlene Lösung, wie Eugene betont, da es Ihr Set nur in einen synchronisierten Dekorator einwickelt, während ein ConcurrentHashMapSet tatsächlich eine Parallelität auf niedriger Ebene implementiert und Ihr Set genauso gut unterstützen kann. Vielen Dank an Herrn Stepanenkov, der das klargestellt hat.

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

Sie können Guaven verwenden Sets.newSetFromMap(map), um eine zu bekommen. Java 6 hat diese Methode auch injava.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;
   }
}

Warum nicht: CopyOnWriteArraySet aus java.util.concurrent verwenden?