HashSet simultâneo <T> no .NET Framework?

Eu tenho a seguinte turma.

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

Preciso alterar o campo "Dados" de diferentes threads, portanto, gostaria de algumas opiniões sobre minha implementação atual segura de thread.

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 uma solução melhor para ir diretamente ao campo e protegê-lo do acesso simultâneo por vários threads?

Sua implementação está correta. Infelizmente, o .NET Framework não fornece um tipo de hashset simultâneo interno. No entanto, existem algumas soluções alternativas.

ConcurrentDictionary (recomendado)

Este primeiro é usar a classe ConcurrentDictionary<TKey, TValue>no espaço para nome System.Collections.Concurrent. No caso, o valor é inútil, portanto, podemos usar um simples byte(1 byte na memória).

private ConcurrentDictionary<string, byte> _data;

Essa é a opção recomendada porque o tipo é seguro para threads e oferece as mesmas vantagens que um HashSet<T> chave e um valor exceto objetos diferentes.

Fonte: Social MSDN

ConcurrentBag

Se você não se importa com as entradas duplicadas, pode usar a classe ConcurrentBag<T>no mesmo espaço para nome da classe anterior.

private ConcurrentBag<string> _data;

Auto-implementação

Por fim, como você fez, você pode implementar seu próprio tipo de dados, usando o lock ou outras formas que o .NET fornece para você ser seguro para threads. Aqui está um ótimo exemplo: Como implementar o ConcurrentHashSet no .Net

A única desvantagem dessa solução é que o tipo HashSet<T>não tem acesso simultâneo oficial, mesmo para operações de leitura.

Cito o código do post vinculado (originalmente escrito por 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: Mova os métodos de bloqueio de entrada para fora dos tryblocos, pois eles podem lançar uma exceção e executar as instruções contidas nos finallyblocos.

Em vez de envolver ConcurrentDictionaryou bloquear um HashSet, criei um real com ConcurrentHashSetbase em ConcurrentDictionary.

Esta implementação suporta operações básicas por item sem HashSetas operações definidas, pois fazem menos sentido nos cenários simultâneos IMO:

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

concurrentHashSet.TryRemove("foo");

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

Saída: 2

Você pode obtê-lo no NuGet aqui e ver a fonte no GitHub aqui .

Como ninguém mais o mencionou, vou oferecer uma abordagem alternativa que pode ou não ser apropriada para seu objetivo específico:

Coleções imutáveis ​​da Microsoft

De um post da equipe da MS por trás:

Embora criar e executar simultaneamente seja mais fácil do que nunca, um dos problemas fundamentais ainda existe: estado compartilhado mutável. A leitura de vários threads geralmente é muito fácil, mas uma vez que o estado precisa ser atualizado, fica muito mais difícil, especialmente em projetos que exigem bloqueio.

Uma alternativa ao bloqueio é fazer uso do estado imutável. É garantido que as estruturas de dados imutáveis ​​nunca mudam e, portanto, podem ser passadas livremente entre diferentes threads, sem se preocupar em pisar no pé de outra pessoa.

Esse design cria um novo problema: Como você gerencia alterações de estado sem copiar todo o estado de cada vez? Isso é especialmente complicado quando há coleções envolvidas.

É aqui que entram as coleções imutáveis.

Essas coleções incluem ImmutableHashSet <T> e ImmutableList <T> .

atuação

Como as coleções imutáveis ​​usam estruturas de dados em árvore abaixo para permitir o compartilhamento estrutural, suas características de desempenho são diferentes das coleções mutáveis. Ao comparar com uma coleção mutável de bloqueio, os resultados dependerão da contenção de bloqueio e dos padrões de acesso. No entanto, retirado de outra postagem no blog sobre as coleções imutáveis:

P: Ouvi dizer que coleções imutáveis ​​são lentas. Estes são diferentes? Posso usá-los quando o desempenho ou a memória são importantes?

R: Essas coleções imutáveis ​​foram altamente ajustadas para oferecer características de desempenho competitivas às coleções mutáveis ​​enquanto equilibram o compartilhamento de memória. Em alguns casos, elas são quase tão rápidas quanto as coleções mutáveis, tanto algoritmicamente quanto em tempo real, às vezes até mais rápidas, enquanto em outros casos são algoritmicamente mais complexas. Em muitos casos, porém, a diferença será insignificante. Geralmente você deve usar o código mais simples para realizar o trabalho e ajustar o desempenho conforme necessário. As coleções imutáveis ​​ajudam a escrever um código simples, especialmente quando a segurança de threads deve ser considerada.

Em outras palavras, em muitos casos, a diferença não será perceptível e você deve optar por uma opção mais simples - que para conjuntos simultâneos seria usada ImmutableHashSet<T>, já que você não possui uma implementação mutável de bloqueio! :-)

A parte complicada de fazer uma ISet<T> concorrente é que os métodos definidos (união, interseção, diferença) são de natureza iterativa. No mínimo, você precisa iterar todos os n membros de um dos conjuntos envolvidos na operação, enquanto bloqueia os dois conjuntos.

Você perde as vantagens de ConcurrentDictionary<T,byte>quando precisa bloquear todo o conjunto durante a iteração. Sem travamento, essas operações não são seguras para threads.

Dada a sobrecarga adicional de ConcurrentDictionary<T,byte>, provavelmente é mais sensato usar o peso mais leveHashSet<T> e envolver tudo em travas.

Se você não precisar das operações definidas, use ConcurrentDictionary<T,byte> e use apenas default(byte)como o valor ao adicionar chaves.

Eu prefiro soluções completas, então fiz isso: lembre-se de que meu Count é implementado de uma maneira diferente, porque não vejo por que alguém deveria ser proibido de ler o hashset enquanto tentava contar seus valores.

@ Zen, Obrigado por começar.

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