Mengapa tidak ada ConcurrentHashSet terhadap ConcurrentHashMap

HashSet didasarkan pada HashMap.

Jika kita melihat HashSet<E>implementasi, semuanya dikelola di bawah HashMap<E,Object>.

<E>digunakan sebagai kunci dari HashMap.

Dan kita tahu bahwa HashMapitu tidak aman. Itu sebabnya kami ada ConcurrentHashMapdi Jawa.

Berdasarkan ini, saya bingung mengapa kita tidak memiliki ConcurrentHashSet yang harus didasarkan pada ConcurrentHashMap?

Apakah ada hal lain yang saya lewatkan? Saya perlu menggunakan Setdalam lingkungan multi-utas.

Juga, Jika saya ingin membuat milik saya sendiri, ConcurrentHashSetbisakah saya mencapainya dengan hanya mengganti HashMapto ConcurrentHashMapdan membiarkan sisanya seperti apa adanya?

Tidak ada tipe bawaan ConcurrentHashSetkarena Anda selalu dapat memperoleh satu set dari peta. Karena ada banyak jenis peta, Anda menggunakan metode untuk menghasilkan satu set dari peta yang diberikan (atau kelas peta).

Sebelum ke Java 8, Anda menghasilkan hash bersamaan yang didukung oleh peta hash bersamaan, dengan menggunakan Collections.newSetFromMap(map)

Di Jawa 8 (ditunjukkan oleh @ Matt), Anda bisa mendapatkan konkuren hash set pandangan via ConcurrentHashMap.newKeySet(). Ini sedikit lebih sederhana daripada yang lama newSetFromMapyang mengharuskan Anda untuk memasukkan objek peta kosong. Tetapi khusus untuk ConcurrentHashMap.

Bagaimanapun, desainer Java bisa saja membuat set antarmuka baru setiap kali antarmuka peta baru dibuat, tetapi pola itu tidak mungkin ditegakkan ketika pihak ketiga membuat peta mereka sendiri. Lebih baik memiliki metode statis yang memperoleh set baru; pendekatan itu selalu berhasil, bahkan ketika Anda membuat implementasi peta Anda sendiri.

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

Dengan Guava 15 Anda juga dapat menggunakan:

Set s = Sets.newConcurrentHashSet();

Seperti yang disebutkan oleh Ray Toal , ini semudah:

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

Sepertinya Java menyediakan implementasi Set bersamaan dengan ConcurrentSkipListSet -nya . Sebuah SkipList Set hanya jenis khusus dari pelaksanaan set. Itu masih mengimplementasikan antarmuka Serializable, Cloneable, Iterable, Collection, NavigableSet, Set, SortedSet. Ini mungkin bekerja untuk Anda jika Anda hanya perlu mengatur antarmuka.

Seperti yang ditunjukkan oleh ini , cara terbaik untuk mendapatkan HashSet yang mampu melakukan konkurensi adalah dengan caraCollections.synchronizedSet()

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

Ini bekerja untuk saya dan saya belum melihat ada orang yang benar-benar menunjuk ke sana.

EDIT Ini kurang efisien daripada solusi yang saat ini disetujui, seperti yang ditunjukkan Eugene, karena itu hanya membungkus set Anda ke dekorator yang disinkronkan, sementara yang ConcurrentHashMapsebenarnya mengimplementasikan konkurensi tingkat rendah dan itu dapat mendukung Set Anda dengan baik. Jadi terima kasih kepada Tn. Stepanenkov karena menjelaskannya.

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

Anda dapat menggunakan jambu biji Sets.newSetFromMap(map)untuk mendapatkannya. Java 6 juga memiliki metode itu dijava.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;
   }
}

Mengapa tidak menggunakan: CopyOnWriteArraySet dari java.util.concurrent?