Concurrent HashSet <T> dans .NET Framework?

J'ai la classe suivante.

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

J'ai besoin de changer le champ "Données" de différents threads, donc j'aimerais avoir des opinions sur mon implémentation thread-safe actuelle.

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);
    }
}

Existe-t-il une meilleure solution, pour aller directement sur le terrain et le protéger de l'accès simultané par plusieurs threads?

Votre implémentation est correcte. Le .NET Framework ne fournit malheureusement pas de type de hachage simultané intégré. Cependant, il existe quelques solutions de contournement.

ConcurrentDictionary (recommandé)

Cette première consiste à utiliser la classe ConcurrentDictionary<TKey, TValue>dans l'espace de noms System.Collections.Concurrent. Dans le cas, la valeur est inutile, on peut donc utiliser un simple byte(1 octet en mémoire).

private ConcurrentDictionary<string, byte> _data;

C'est l'option recommandée car le type est thread-safe et vous offre les mêmes avantages qu'une HashSet<T>clé et une valeur sauf sont des objets différents.

Source: MSDN social

ConcurrentBag

Si les entrées en double ne vous dérangent pas, vous pouvez utiliser la classe ConcurrentBag<T>dans le même espace de noms que la classe précédente.

private ConcurrentBag<string> _data;

Auto-implémentation

Enfin, comme vous l'avez fait, vous pouvez implémenter votre propre type de données, en utilisant le verrouillage ou d'autres moyens que le .NET vous offre pour être thread-safe. Voici un excellent exemple: Comment implémenter ConcurrentHashSet dans .Net

Le seul inconvénient de cette solution est que le type HashSet<T>n'a pas officiellement d'accès simultané, même pour les opérations de lecture.

Je cite le code de l'article lié (écrit à l'origine par Ben Mosher ).

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
    }
}

EDIT: Déplacez les méthodes de verrouillage d'entrée à l'extérieur des tryblocs, car elles pourraient lever une exception et exécuter les instructions contenues dans les finallyblocs.

Au lieu d'envelopper un ConcurrentDictionaryou de verrouiller un, HashSetj'ai créé un réel ConcurrentHashSetbasé sur ConcurrentDictionary.

Cette implémentation prend en charge les opérations de base par article sans HashSetles opérations d'ensemble car elles ont moins de sens dans les scénarios simultanés IMO:

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

concurrentHashSet.TryRemove("foo");

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

Sortie: 2

Vous pouvez l'obtenir à partir de NuGet ici et voir la source sur GitHub ici .

Étant donné que personne d'autre ne l'a mentionné, je proposerai une approche alternative qui peut ou non être appropriée à votre objectif particulier:

Collections immuables Microsoft

À partir d'un article de blog de l'équipe MS derrière:

Bien que la création et l'exécution simultanées soient plus faciles que jamais, l'un des problèmes fondamentaux existe toujours: l'état partagé mutable. La lecture à partir de plusieurs threads est généralement très facile, mais une fois que l'état doit être mis à jour, cela devient beaucoup plus difficile, en particulier dans les conceptions nécessitant un verrouillage.

Une alternative au verrouillage consiste à utiliser l'état immuable. Les structures de données immuables sont garanties de ne jamais changer et peuvent donc être passées librement entre différents threads sans se soucier de marcher sur les orteils de quelqu'un d'autre.

Cette conception crée cependant un nouveau problème: comment gérer les changements d'état sans copier l'état entier à chaque fois? Ceci est particulièrement délicat lorsque des collections sont impliquées.

C'est là qu'interviennent les collections immuables.

Ces collections incluent ImmutableHashSet <T> et ImmutableList <T> .

Performance

Étant donné que les collections immuables utilisent des structures de données arborescentes en dessous pour permettre le partage structurel, leurs caractéristiques de performance sont différentes de celles des collections mutables. Lors d'une comparaison avec une collection mutable verrouillable, les résultats dépendront du conflit de verrouillage et des modèles d'accès. Cependant, tiré d' un autre article de blog sur les collections immuables:

Q: J'ai entendu dire que les collections immuables sont lentes. Sont-ils différents? Puis-je les utiliser lorsque les performances ou la mémoire sont importantes?

R: Ces collections immuables ont été hautement réglées pour avoir des caractéristiques de performances compétitives par rapport aux collections mutables tout en équilibrant le partage de mémoire. Dans certains cas, ils sont presque aussi rapides que les collections mutables à la fois algorithmiquement et en temps réel, parfois même plus rapides, tandis que dans d'autres cas, ils sont plus complexes sur le plan algorithmique. Dans de nombreux cas, cependant, la différence sera négligeable. En règle générale, vous devez utiliser le code le plus simple pour faire le travail, puis régler les performances si nécessaire. Les collections immuables vous aident à écrire du code simple, en particulier lorsque la sécurité des threads doit être prise en compte.

En d'autres termes, dans de nombreux cas, la différence ne sera pas perceptible et vous devriez opter pour le choix le plus simple - qui serait à utiliser pour les ensembles simultanés ImmutableHashSet<T>, car vous n'avez pas d'implémentation de verrouillage mutable existante! :-)

La partie délicate de la création d'un ISet<T>concurrent est que les méthodes d'ensemble (union, intersection, différence) sont de nature itérative. Au minimum, vous devez parcourir les n membres de l'un des ensembles impliqués dans l'opération, tout en verrouillant les deux ensembles.

Vous perdez les avantages d'un ConcurrentDictionary<T,byte>lorsque vous devez verrouiller l'ensemble entier pendant l'itération. Sans verrouillage, ces opérations ne sont pas thread-safe.

Compte tenu des frais généraux supplémentaires ConcurrentDictionary<T,byte>, il est probablement plus sage d'utiliser le poids plus léger HashSet<T>et de tout entourer de serrures.

Si vous n'avez pas besoin des opérations définies, utilisez ConcurrentDictionary<T,byte>et utilisez simplement default(byte)comme valeur lorsque vous ajoutez des clés.

Je préfère les solutions complètes, alors j'ai fait ceci: Attention, mon compte est implémenté d'une manière différente car je ne vois pas pourquoi on devrait interdire de lire le hashset en essayant de compter ses valeurs.

@Zen, merci d'avoir démarré.

[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; }
    }
}