Twoja implementacja jest prawidłowa. .NET Framework nie zapewnia niestety wbudowanego współbieżnego typu hashset. Istnieją jednak pewne obejścia.
ConcurrentDictionary (zalecane)
Pierwszym jest użycie klasy ConcurrentDictionary<TKey, TValue>
w przestrzeni nazw System.Collections.Concurrent
. W takim przypadku wartość jest bezcelowa, więc możemy użyć prostego byte
(1 bajt w pamięci).
private ConcurrentDictionary<string, byte> _data;
Jest to zalecana opcja, ponieważ typ jest bezpieczny dla wątków i zapewnia te same korzyści, co HashSet<T>
klucz z wyjątkiem i wartość to różne obiekty.
Źródło: Social MSDN
ConcurrentBag
Jeśli nie masz nic przeciwko zduplikowanym wpisom, możesz użyć klasy ConcurrentBag<T>
w tej samej przestrzeni nazw, co poprzednia klasa.
private ConcurrentBag<string> _data;
Samodzielna realizacja
Wreszcie, tak jak to zrobiłeś, możesz zaimplementować własny typ danych, używając blokady lub innych sposobów, które zapewnia .NET, aby zapewnić bezpieczeństwo wątków. Oto wspaniały przykład: Jak zaimplementować ConcurrentHashSet w .Net
Jedyną wadą tego rozwiązania jest to, że typ HashSet<T>
nie jest oficjalnie równoczesny, nawet w przypadku operacji odczytu.
Cytuję kod posta, do którego prowadzi link (pierwotnie napisany przez Bena Moshera ).
using System;
using System.Collections.Generic;
using System.Threading;
namespace BlahBlah.Utilities
{
public class ConcurrentHashSet<T> : IDisposable
{
private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
private readonly HashSet<T> _hashSet = new HashSet<T>();
#region Implementation of ICollection<T> ...ish
public bool Add(T item)
{
_lock.EnterWriteLock();
try
{
return _hashSet.Add(item);
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
}
public void Clear()
{
_lock.EnterWriteLock();
try
{
_hashSet.Clear();
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
}
public bool Contains(T item)
{
_lock.EnterReadLock();
try
{
return _hashSet.Contains(item);
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
}
public bool Remove(T item)
{
_lock.EnterWriteLock();
try
{
return _hashSet.Remove(item);
}
finally
{
if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
}
}
public int Count
{
get
{
_lock.EnterReadLock();
try
{
return _hashSet.Count;
}
finally
{
if (_lock.IsReadLockHeld) _lock.ExitReadLock();
}
}
}
#endregion
#region Dispose
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
if (_lock != null)
_lock.Dispose();
}
~ConcurrentHashSet()
{
Dispose(false);
}
#endregion
}
}
EDYCJA: Przenieś metody blokady wejścia poza try
bloki, ponieważ mogą one zgłosić wyjątek i wykonać instrukcje zawarte w finally
blokach.
System.Collections.Concurrent