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>相同的优点。

来源：Social MSDN

<强> ConcurrentBag

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

private ConcurrentBag<string> _data;

<强>自实施

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

此解决方案的唯一缺点是类型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

我没有打包HashSet或锁定ConcurrentHashSet，而是根据ConcurrentDictionary创建了实际的HashSet。

此实现支持每个项目的基本操作而没有var concurrentHashSet = new ConcurrentHashSet<string>( new[] { "hamster", "HAMster", "bar", }, StringComparer.OrdinalIgnoreCase); concurrentHashSet.TryRemove("foo"); if (concurrentHashSet.Contains("BAR")) { Console.WriteLine(concurrentHashSet.Count); }的设置操作，因为它们在并发场景中没有意义IMO：

{{1}}

输出：2

你可以从NuGet here获取它并在GitHub here上查看来源。

Answer 3

由于没有其他人提及，我会提供一种替代方法，可能适用于您的特定目的，也可能不适合您：

Microsoft Immutable Collections

来自MS团队的blog post：

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

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

这种设计虽然会产生一个新问题：如何在不复制整个状态的情况下管理状态变化？当涉及收藏时，这尤其棘手。

这是不可变集合的来源。

这些馆藏包括ImmutableHashSet<T>和ImmutableList<T>。

性能

由于不可变集合使用下面的树数据结构来实现结构共享，因此它们的性能特征与可变集合不同。与锁定可变集合进行比较时，结果将取决于锁争用和访问模式。但是，从another blog post获取有关不可变集合的信息：

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

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

换句话说，在许多情况下，差异不会明显，你应该选择更简单的选择 - 对于并发集合将使用ImmutableHashSet<T>，因为你没有现有的锁定可变执行！： - ）

Answer 4

我更喜欢完整的解决方案，所以我这样做：请注意我的Count以不同的方式实现，因为我不明白为什么在尝试计算其值时应该禁止读取hashset。

@Zen，感谢您的开始。

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

Answer 5

关于使ISet<T>并发的棘手部分是set方法（union，intersection，difference）本质上是迭代的。至少，您必须迭代操作中涉及的其中一个集合的所有n个成员，同时锁定两个集合。

当您必须在迭代期间锁定整个集合时，您将失去ConcurrentDictionary<T,byte>的优势。没有锁定，这些操作不是线程安全的。

考虑到ConcurrentDictionary<T,byte>增加的开销，使用较轻的重量HashSet<T>并且只包围锁中的所有内容可能更明智。

如果您不需要设置操作，请使用ConcurrentDictionary<T,byte>，并在添加密钥时使用default(byte)作为值。

.NET Framework中的并发HashSet <t>？</t>

5 个答案:

Microsoft Immutable Collections

性能