.NET Framework中的并发HashSet <T>？

Question

我有以下课程.

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

我需要从不同的线程更改字段"Data",所以我想对我当前的线程安全实现有一些看法.

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

是否有更好的解决方案,直接进入现场并保护它免受多线程的并发访问？

Answer 1

您的实施是正确的.遗憾的是,.NET Framework不提供内置的并发hashset类型.但是,有一些解决方法.

ConcurrentDictionary(推荐)

第一个是ConcurrentDictionary<TKey, TValue>在命名空间中使用该类System.Collections.Concurrent.在这种情况下,值是没有意义的,所以我们可以使用一个简单的byte(内存中的1个字节).

private ConcurrentDictionary<string, byte> _data;

这是推荐的选项,因为类型是线程安全的,并且提供与HashSet<T>except键相同的优点,值是不同的对象.

来源:社交MSDN

ConcurrentBag

如果您不介意重复条目,则可以ConcurrentBag<T>在上一个类的同一名称空间中使用该类.

private ConcurrentBag<string> _data;

自我实现

最后,正如您所做的那样,您可以使用锁定或.NET为您提供线程安全的其他方式来实现您自己的数据类型.这是一个很好的例子:如何在.Net中实现ConcurrentHashSet

该解决方案的唯一缺点是该类型HashSet<T>不能正式并发访问,即使对于读取操作也是如此.

我引用链接帖子的代码(最初由Ben Mosher编写).

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

编辑:移动try块的入口锁定方法,因为它们可以抛出异常并执行finally块中包含的指令.

Answer 2

而不是包装ConcurrentDictionary或锁定HashSet我创建的实际ConcurrentHashSet基于ConcurrentDictionary.

这个实现支持每个项目的基本操作而没有HashSet设置操作,因为它们在并发场景中没有意义IMO:

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

concurrentHashSet.TryRemove("foo");

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

输出:2

您可以从的NuGet得到它在这里和在Github上查看源在这里.

Answer 3

由于没有人提及它,我将提供一种替代方法,可能适用于您的特定目的,也可能不适合您:

Microsoft Immutable Collections

来自MS团队的博客文章背后:

虽然并发创建和运行比以往更容易,但仍然存在一个基本问题:可变共享状态.从多个线程读取通常非常简单,但是一旦状态需要更新,它就会变得更加困难,尤其是在需要锁定的设计中.

锁定的替代方法是使用不可变状态.不可变数据结构保证永远不会改变,因此可以在不同的线程之间自由传递,而不必担心踩到别人的脚趾.

这种设计会产生一个新问题:如何管理状态变化而不是每次都复制整个状态？当涉及集合时,这尤其棘手.

这是不可变集合的用武之地.

这些集合包括ImmutableHashSet <T>和ImmutableList <T>.

性能

由于不可变集合使用下面的树数据结构来实现结构共享,因此它们的性能特征与可变集合不同.与锁定可变集合进行比较时,结果将取决于锁争用和访问模式.但是,从另一篇关于不可变集合的博客文章中获取:

问:我听说过不可变的集合很慢.这些有什么不同吗？当性能或内存很重要时,我可以使用它们吗？

答:这些不可变的集合经过高度调整,在可比较的集合中具有竞争性的性能特征,同时平衡了内存共享.在某些情况下,它们几乎与可变集合一样快,无论是在算法上还是在实际时间内,有时甚至更快,而在其他情况下,它们在算法上更复杂.然而,在许多情况下,差异可以忽略不计.通常,您应该使用最简单的代码来完成工作,然后根据需要调整性能.不可变集合可以帮助您编写简单的代码,尤其是在必须考虑线程安全时.

换句话说,在许多情况下,差异不会明显,你应该选择更简单的选择 - 对于并发集将使用ImmutableHashSet<T>,因为你没有现有的锁定可变实现!:-)