Concurrent HashSet <T> w .NET Framework?

Mam następującą klasę.

class Test{
    public HashSet<string> Data = new HashSet<string>();
}

Muszę zmienić pole „Dane” z różnych wątków, więc chciałbym poznać opinie na temat mojej obecnej implementacji bezpiecznej wątkowo.

class Test{
    public HashSet<string> Data = new HashSet<string>();

    public void Add(string Val){
            lock(Data) Data.Add(Val);
    }

    public void Remove(string Val){
            lock(Data) Data.Remove(Val);
    }
}

Czy jest lepsze rozwiązanie, aby przejść bezpośrednio do pola i zabezpieczyć je przed równoczesnym dostępem wielu wątków?

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 trybloki, ponieważ mogą one zgłosić wyjątek i wykonać instrukcje zawarte w finallyblokach.

Zamiast zawijać ConcurrentDictionarylub blokować plik HashSet, utworzyłem rzeczywisty ConcurrentHashSetoparty na ConcurrentDictionary.

Ta implementacja obsługuje podstawowe operacje na element bez HashSetustawionych operacji, ponieważ mają one mniej sensu w współbieżnych scenariuszach IMO:

var concurrentHashSet = new ConcurrentHashSet<string>(
    new[]
    {
        "hamster",
        "HAMster",
        "bar",
    },
    StringComparer.OrdinalIgnoreCase);

concurrentHashSet.TryRemove("foo");

if (concurrentHashSet.Contains("BAR"))
{
    Console.WriteLine(concurrentHashSet.Count);
}

Wyjście: 2

Możesz go pobrać z NuGet tutaj i zobaczyć źródło na GitHub tutaj .

Ponieważ nikt inny o tym nie wspomniał, zaproponuję alternatywne podejście, które może, ale nie musi być odpowiednie dla twojego konkretnego celu:

Niezmienne kolekcje firmy Microsoft

Z posta na blogu zespołu MS odpowiedzialnego za:

Chociaż tworzenie i uruchamianie współbieżne jest łatwiejsze niż kiedykolwiek, jeden z podstawowych problemów nadal istnieje: zmienny stan współdzielony. Czytanie z wielu wątków jest zazwyczaj bardzo łatwe, ale gdy stan musi zostać zaktualizowany, staje się znacznie trudniejszy, szczególnie w projektach wymagających blokowania.

Alternatywą dla blokowania jest wykorzystanie niezmiennego stanu. Niezmienne struktury danych mają gwarancję, że nigdy się nie zmienią i dzięki temu mogą być swobodnie przekazywane między różnymi wątkami bez obawy o nadepnięcie czyimś palcom.

Ten projekt stwarza jednak nowy problem: Jak zarządzać zmianami stanu bez kopiowania całego stanu za każdym razem? Jest to szczególnie trudne w przypadku kolekcji.

W tym miejscu pojawiają się niezmienne kolekcje.

Te kolekcje obejmują ImmutableHashSet <T> i ImmutableList <T> .

Występ

Ponieważ niezmienne kolekcje używają drzewiastych struktur danych pod spodem, aby umożliwić współużytkowanie strukturalne, ich charakterystyki wydajnościowe różnią się od kolekcji zmiennych. W porównaniu z blokującą kolekcją mutowalną, wyniki będą zależeć od rywalizacji o blokady i wzorców dostępu. Jednak zaczerpnięte z innego posta na blogu o niezmiennych kolekcjach:

P: Słyszałem, że niezmienne kolekcje są powolne. Czy te są inne? Czy mogę ich używać, gdy ważna jest wydajność lub pamięć?

O: Te niezmienne kolekcje zostały w dużym stopniu dostrojone, aby mieć konkurencyjną charakterystykę wydajności w porównaniu z kolekcjami zmiennymi, jednocześnie równoważąc współdzielenie pamięci. W niektórych przypadkach są one prawie tak szybkie, jak zbiory podlegające zmianom, zarówno algorytmicznie, jak iw czasie rzeczywistym, czasami nawet szybsze, podczas gdy w innych przypadkach są algorytmicznie bardziej złożone. Jednak w wielu przypadkach różnica będzie znikoma. Ogólnie rzecz biorąc, do wykonania zadania należy użyć najprostszego kodu, a następnie dostroić wydajność w razie potrzeby. Niezmienne kolekcje ułatwiają pisanie prostego kodu, zwłaszcza gdy należy wziąć pod uwagę bezpieczeństwo wątków.

Innymi słowy, w wielu przypadkach różnica nie będzie zauważalna i powinieneś wybrać prostszy wybór - który w przypadku zestawów współbieżnych byłby odpowiedni ImmutableHashSet<T>, ponieważ nie masz istniejącej blokującej mutowalnej implementacji! :-)

Najtrudniejsze w tworzeniu ISet<T>współbieżności jest to, że metody zestawu (suma, przecięcie, różnica) mają charakter iteracyjny. Musisz przynajmniej wykonać iterację po wszystkich n elementach jednego ze zbiorów zaangażowanych w operację, jednocześnie blokując oba zestawy.

Tracisz zalety a, ConcurrentDictionary<T,byte>gdy musisz zablokować cały zestaw podczas iteracji. Bez blokowania operacje te nie są bezpieczne dla wątków.

Biorąc pod uwagę dodatkowe koszty ConcurrentDictionary<T,byte>, prawdopodobnie rozsądniej jest po prostu użyć mniejszej wagi HashSet<T>i po prostu otoczyć wszystko zamkami.

Jeśli nie potrzebujesz operacji na zestawach, użyj ConcurrentDictionary<T,byte>i po prostu użyj default(byte)jako wartości podczas dodawania kluczy.

Wolę kompletne rozwiązania, więc zrobiłem to: Pamiętaj, że mój Count jest zaimplementowany w inny sposób, ponieważ nie widzę, dlaczego należy zabronić odczytywania hashsetu podczas próby policzenia jego wartości.

@Zen, dziękujemy za rozpoczęcie.

[DebuggerDisplay("Count = {Count}")]
[Serializable]
public class ConcurrentHashSet<T> : ICollection<T>, ISet<T>, ISerializable, IDeserializationCallback
{
    private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);

    private readonly HashSet<T> _hashSet = new HashSet<T>();

    public ConcurrentHashSet()
    {
    }

    public ConcurrentHashSet(IEqualityComparer<T> comparer)
    {
        _hashSet = new HashSet<T>(comparer);
    }

    public ConcurrentHashSet(IEnumerable<T> collection)
    {
        _hashSet = new HashSet<T>(collection);
    }

    public ConcurrentHashSet(IEnumerable<T> collection, IEqualityComparer<T> comparer)
    {
        _hashSet = new HashSet<T>(collection, comparer);
    }

    protected ConcurrentHashSet(SerializationInfo info, StreamingContext context)
    {
        _hashSet = new HashSet<T>();

        // not sure about this one really...
        var iSerializable = _hashSet as ISerializable;
        iSerializable.GetObjectData(info, context);
    }

    #region Dispose

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
            if (_lock != null)
                _lock.Dispose();
    }

    public IEnumerator<T> GetEnumerator()
    {
        return _hashSet.GetEnumerator();
    }

    ~ConcurrentHashSet()
    {
        Dispose(false);
    }

    public void OnDeserialization(object sender)
    {
        _hashSet.OnDeserialization(sender);
    }

    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        _hashSet.GetObjectData(info, context);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    #endregion

    public void Add(T item)
    {
        _lock.EnterWriteLock();
        try
        {
            _hashSet.Add(item);
        }
        finally
        {
            if(_lock.IsWriteLockHeld) _lock.ExitWriteLock();
        }
    }

    public void UnionWith(IEnumerable<T> other)
    {
        _lock.EnterWriteLock();
        _lock.EnterReadLock();
        try
        {
            _hashSet.UnionWith(other);
        }
        finally
        {
            if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
            if (_lock.IsReadLockHeld) _lock.ExitReadLock();
        }
    }

    public void IntersectWith(IEnumerable<T> other)
    {
        _lock.EnterWriteLock();
        _lock.EnterReadLock();
        try
        {
            _hashSet.IntersectWith(other);
        }
        finally
        {
            if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
            if (_lock.IsReadLockHeld) _lock.ExitReadLock();
        }
    }

    public void ExceptWith(IEnumerable<T> other)
    {
        _lock.EnterWriteLock();
        _lock.EnterReadLock();
        try
        {
            _hashSet.ExceptWith(other);
        }
        finally
        {
            if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
            if (_lock.IsReadLockHeld) _lock.ExitReadLock();
        }
    }

    public void SymmetricExceptWith(IEnumerable<T> other)
    {
        _lock.EnterWriteLock();
        try
        {
            _hashSet.SymmetricExceptWith(other);
        }
        finally
        {
            if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
        }
    }

    public bool IsSubsetOf(IEnumerable<T> other)
    {
        _lock.EnterWriteLock();
        try
        {
            return _hashSet.IsSubsetOf(other);
        }
        finally
        {
            if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
        }
    }

    public bool IsSupersetOf(IEnumerable<T> other)
    {
        _lock.EnterWriteLock();
        try
        {
            return _hashSet.IsSupersetOf(other);
        }
        finally
        {
            if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
        }
    }

    public bool IsProperSupersetOf(IEnumerable<T> other)
    {
        _lock.EnterWriteLock();
        try
        {
            return _hashSet.IsProperSupersetOf(other);
        }
        finally
        {
            if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
        }
    }

    public bool IsProperSubsetOf(IEnumerable<T> other)
    {
        _lock.EnterWriteLock();
        try
        {
            return _hashSet.IsProperSubsetOf(other);
        }
        finally
        {
            if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
        }
    }

    public bool Overlaps(IEnumerable<T> other)
    {
        _lock.EnterWriteLock();
        try
        {
            return _hashSet.Overlaps(other);
        }
        finally
        {
            if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
        }
    }

    public bool SetEquals(IEnumerable<T> other)
    {
        _lock.EnterWriteLock();
        try
        {
            return _hashSet.SetEquals(other);
        }
        finally
        {
            if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
        }
    }

    bool ISet<T>.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.EnterWriteLock();
        try
        {
            return _hashSet.Contains(item);
        }
        finally
        {
            if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
        }
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        _lock.EnterWriteLock();
        try
        {
            _hashSet.CopyTo(array, arrayIndex);
        }
        finally
        {
            if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
        }
    }

    public bool Remove(T item)
    {
        _lock.EnterWriteLock();
        try
        {
            return _hashSet.Remove(item);
        }
        finally
        {
            if (_lock.IsWriteLockHeld) _lock.ExitWriteLock();
        }
    }

    public int Count
    {
        get
        {
            _lock.EnterWriteLock();
            try
            {
                return _hashSet.Count;
            }
            finally
            {
                if(_lock.IsWriteLockHeld) _lock.ExitWriteLock();
            }

        }
    }

    public bool IsReadOnly
    {
        get { return false; }
    }
}