线程安全列表财产

Question

我想要一个 List 的实现作为一个属性，毫无疑问可以线程安全地使用。

像这样的事情：

private List<T> _list;

private List<T> MyT
{
    get { // return a copy of _list; }
    set { _list = value; }
}

我似乎仍然需要返回集合的副本（克隆），因此如果我们在某个地方迭代集合并同时设置集合，则不会引发异常。

如何实现线程安全的集合属性？

Answer 1

如果您的目标是 .Net 4，系统中有一些选项。 Collections.Concurrent 命名空间

在这种情况下，您可以使用 ConcurrentBag 而不是 List

Answer 2

即使它获得了最多的选票，通常也不能将 System.Collections.Concurrent.ConcurrentBag 作为 System.Collections.Generic.List 的线程安全替代品; 照原样（Radek Stromský 已经指出）未订购。

但是有一个名为 System.Collections.Generic.SynchronizedCollection 的类，自 .NET 3.0 起就已成为框架的一部分，但它隐藏在人们意想不到的位置它鲜为人知，而且可能你从来没有偶然发现过它（至少我从来没有）。

SynchronizedCollection 被编译为程序集System.ServiceModel.dll（它是客户端配置文件的一部分，但不是可移植类库的一部分）。

编辑：还有一个 NuGet 包“System.ServiceModel.Primitives”，自版本 ~4.6.0 起包含 System.Collections.Generic.SynchronizedCollection。< br>（归功于 Roi Shabtai）

Answer 3

C# 的 ArrayList 类有一个 同步方法。

var threadSafeArrayList = ArrayList.Synchronized(new ArrayList());

这将返回一个围绕 IList 的任何实例的线程安全包装器。所有操作都需要通过包装器来执行，以保证线程安全。

但请注意，这是通过锁定集合来实现的，这可能会影响性能。来自MS 文档：

包装器的工作原理是在每次添加或删除操作时锁定整个集合。因此，每个尝试访问集合的线程都必须等待轮到它获取一个锁。 此过程不可扩展，并且可能会导致大型集合的性能显着下降。此外，该设计不受竞争条件的影响。

这对您来说可能不会影响交易，但值得记住。

Answer 4

我认为制作一个示例 ThreadSafeList 类会很容易：

public class ThreadSafeList<T> : IList<T>
{
    protected List<T> _internalList = new List<T>();

    // Other Elements of IList implementation

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

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return Clone().GetEnumerator();
    }

    protected static object _lock = new object();

    public List<T> Clone()
    {
        List<T> newList = new List<T>();

        lock (_lock)
        {
            _internalList.ForEach(x => newList.Add(x));
        }

        return newList;
    }
}

您只需在请求枚举器之前克隆列表，因此任何枚举都会处理运行时无法修改的副本。

Answer 5

即使接受的答案是 ConcurrentBag，我也不认为它在所有情况下都是列表的真正替代品，正如 Radek 对答案的评论所说：“ConcurrentBag 是无序集合，因此与 List 不同，它不能保证排序。此外，您无法通过索引访问项目”。

因此，如果您使用 .NET 4.0 或更高版本，解决方法可能是使用 ConcurrentDictionary，其中整数 TKey 作为数组索引，TValue 作为数组值。这是 Pluralsight 的 C# 并发集合课程 中推荐的替换列表的方法。 ConcurrentDictionary 解决了上面提到的两个问题：索引访问和排序（我们不能依赖排序，因为它是底层的哈希表，但当前的 .NET 实现保存了元素添加的顺序）。

Answer 6

在 .NET Core（任何版本）中，您可以使用 ImmutableList，它具有 List 的所有功能。

Answer 7

回复自我最初的答案以来的所有答案：

人们找到了这些解决方案：

• 使用 SynchronizedCollection - 源代码 与下面的 SynchronizedList 几乎相同，具有相同的功能和问题，
• 使用 ArrayList.Synchronized - 这将返回 a SyncIList，与下面的 SynchronizedList 相同，只是不
• 通用列表的线程安全形式，每次访问时都克隆它 - 我相信使用 ThreadLocal 或 AsyncLocal 可以显着改进所提供的实现，但
• 使用 Collections.Concurrent 命名空间中的各种类组合的任何性能测试仍然会失败 -这些包含 ICollection 的一些不错的选项，但不适用于用于索引访问的 IList
• 使用 ConcurrentDictionary，以索引作为键，来模拟 IList - 这是我见过的最好的想法之一，但它并不是真的本着 IList 的精神，这意味着 O(1) 索引读取/追加复杂性和插入/删除的一些复杂性，以及 O(n) 空间复杂性。另外，IndexOf 和排序操作怎么样？

大多数针对 SynchronizedList 类的抱怨都与以下方面有关：

• 锁机制的缓慢 - 性能计算根据使用列表的场景而有很大差异，因此对于
• 使用 lock(object) 而不是使用 SemaphoreSlim 的 模糊要求，这是一个有效的选项- 好吧，这是我的抱怨:)但是修复代码以使用它是微不足道的，

可以实现更复杂的锁系统，例如单个行，行组等。这将开始看起来像是实现您自己的数据库，尽管。编写高性能集合是一门艺术，并且与您想要使用它的特定场景紧密结合。

我仍然相信，对于一般使用场景，这里的简单解决方案是最通用的。

C5 集合库是伟大集合设计的灵感之一，它如此处理并发性：

• 没有并发集合（按设计），因为他们认为可以实现简单的锁定机制，但是当多个集合被访问时，场景会变得非常复杂。同时
• “基于树的集合可以在修改时安全地枚举” - 他们推荐“模式 66”：“可以拍摄树的快照，然后枚举该快照的项目，同时修改原始树同时”

原始答案：

如果您查看 T 列表的源代码（https://referencesource.microsoft.com/#mscorlib/system/collections/generic/list.cs,c66df6f36c131877）你会注意到那里有一个类（当然是内部的 -为什么，微软，为什么？！？！）称为T的SynchronizedList。我将代码复制粘贴到此处：

   [Serializable()]
    internal class SynchronizedList : IList<T> {
        private List<T> _list;
        private Object _root;

        internal SynchronizedList(List<T> list) {
            _list = list;
            _root = ((System.Collections.ICollection)list).SyncRoot;
        }

        public int Count {
            get {
                lock (_root) { 
                    return _list.Count; 
                }
            }
        }

        public bool IsReadOnly {
            get {
                return ((ICollection<T>)_list).IsReadOnly;
            }
        }

        public void Add(T item) {
            lock (_root) { 
                _list.Add(item); 
            }
        }

        public void Clear() {
            lock (_root) { 
                _list.Clear(); 
            }
        }

        public bool Contains(T item) {
            lock (_root) { 
                return _list.Contains(item);
            }
        }

        public void CopyTo(T[] array, int arrayIndex) {
            lock (_root) { 
                _list.CopyTo(array, arrayIndex);
            }
        }

        public bool Remove(T item) {
            lock (_root) { 
                return _list.Remove(item);
            }
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
            lock (_root) { 
                return _list.GetEnumerator();
            }
        }

        IEnumerator<T> IEnumerable<T>.GetEnumerator() {
            lock (_root) { 
                return ((IEnumerable<T>)_list).GetEnumerator();
            }
        }

        public T this[int index] {
            get {
                lock(_root) {
                    return _list[index];
                }
            }
            set {
                lock(_root) {
                    _list[index] = value;
                }
            }
        }

        public int IndexOf(T item) {
            lock (_root) {
                return _list.IndexOf(item);
            }
        }

        public void Insert(int index, T item) {
            lock (_root) {
                _list.Insert(index, item);
            }
        }

        public void RemoveAt(int index) {
            lock (_root) {
                _list.RemoveAt(index);
            }
        }
    }

我个人认为他们知道使用 SemaphoreSlim 可以创建，但没有到达它。

Answer 8

我建议任何在多线程场景中处理 List 的人看看 不可变集合 特别是 ImmutableArray。

我发现它在以下情况下非常有用：

1. 列表中的项目相对较少
2. 读/写操作不多 大量
3. 并发访问（即以读取模式访问列表的许多线程）

当您需要实现时也很有用某种类似事务的行为（即在失败时恢复插入/更新/删除操作）

Answer 9

似乎许多发现此问题的人都想要一个线程安全的索引动态大小的集合。我所知道的最接近和最简单的事情是。

System.Collections.Concurrent.ConcurrentDictionary<int, YourDataType>

如果您想要正常的索引行为，这将要求您确保您的密钥正确递增。如果您小心的话，.count() 足以作为您添加的任何新键值对的键。

Answer 10

您还可以使用更原始的

Monitor.Enter(lock);
Monitor.Exit(lock);

锁使用（请参阅这篇文章C# 锁定在锁块中重新分配的对象)。

如果您期望代码中出现异常，那么这并不安全，但它允许您执行类似以下操作：

using System;
using System.Collections.Generic;
using System.Threading;
using System.Linq;

public class Something
{
    private readonly object _lock;
    private readonly List<string> _contents;

    public Something()
    {
        _lock = new object();

        _contents = new List<string>();
    }

    public Modifier StartModifying()
    {
        return new Modifier(this);
    }

    public class Modifier : IDisposable
    {
        private readonly Something _thing;

        public Modifier(Something thing)
        {
            _thing = thing;

            Monitor.Enter(Lock);
        }

        public void OneOfLotsOfDifferentOperations(string input)
        {
            DoSomethingWith(input);
        }

        private void DoSomethingWith(string input)
        {
            Contents.Add(input);
        }

        private List<string> Contents
        {
            get { return _thing._contents; }
        }

        private object Lock
        {
            get { return _thing._lock; }
        }

        public void Dispose()
        {
            Monitor.Exit(Lock);
        }
    }
}

public class Caller
{
    public void Use(Something thing)
    {
        using (var modifier = thing.StartModifying())
        {
            modifier.OneOfLotsOfDifferentOperations("A");
            modifier.OneOfLotsOfDifferentOperations("B");

            modifier.OneOfLotsOfDifferentOperations("A");
            modifier.OneOfLotsOfDifferentOperations("A");
            modifier.OneOfLotsOfDifferentOperations("A");
        }
    }
}

这样做的好处之一是您将在一系列操作的持续时间内获得锁定（而不是锁定）每个操作）。这意味着输出应该以正确的块形式出现（我对此的使用是从外部进程将一些输出显示到屏幕上）

我真的很喜欢 ThreadSafeList 的简单性 + 透明度 + 它在阻止崩溃方面发挥了重要作用

Answer 11

我相信 _list.ToList() 会给你一份副本。如果需要，您也可以查询它，例如：

_list.Select("query here").ToList(); 

无论如何，msdn 说这确实是一个副本，而不仅仅是一个参考。哦，是的，您需要锁定 set 方法，正如其他人指出的那样。

Answer 12

查看原始示例，人们可能会猜测其目的是能够简单地用新列表替换列表。该房产的设置者告诉我们这件事。

Micrisoft 的线程安全集合用于安全地添加和删除集合中的项目。但是，如果在应用程序逻辑中您打算用新集合替换该集合，人们可能会再次猜测，不需要 List 的添加和删除功能。

如果是这种情况，简单的答案是使用 IReadOnlyList 接口：

 private IReadOnlyList<T> _readOnlyList = new List<T>();

    private IReadOnlyList<T> MyT
    {
       get { return _readOnlyList; }
       set { _readOnlyList = value; }
    }

在这种情况下不需要使用任何锁定，因为无法修改集合。如果在设置器中“_readOnlyList = value;”将被更复杂的东西所取代，然后可能需要锁。

Answer 13

基本上如果你想安全地枚举，你需要使用锁。

这方面请参考MSDN。 http://msdn.microsoft.com/en-us/library/6sh2ey19.aspx

以下是您可能感兴趣的 MSDN 部分：

此类型的公共静态（在 Visual Basic 中为共享）成员是线程安全的。不保证任何实例成员都是线程安全的。

只要集合不被修改，List 就可以同时支持多个读取器。枚举集合本质上不是线程安全的过程。在枚举与一个或多个写访问争用的极少数情况下，确保线程安全的唯一方法是在整个枚举期间锁定集合。要允许多个线程访问集合以进行读写，您必须实现自己的同步。

Answer 14

这是没有锁的线程安全列表的类

 public class ConcurrentList   
    {
        private long _i = 1;
        private ConcurrentDictionary<long, T> dict = new ConcurrentDictionary<long, T>();  
        public int Count()
        {
            return dict.Count;
        }
         public List<T> ToList()
         {
            return dict.Values.ToList();
         }

        public T this[int i]
        {
            get
            {
                long ii = dict.Keys.ToArray()[i];
                return dict[ii];
            }
        }
        public void Remove(T item)
        {
            T ov;
            var dicItem = dict.Where(c => c.Value.Equals(item)).FirstOrDefault();
            if (dicItem.Key > 0)
            {
                dict.TryRemove(dicItem.Key, out ov);
            }
            this.CheckReset();
        }
        public void RemoveAt(int i)
        {
            long v = dict.Keys.ToArray()[i];
            T ov;
            dict.TryRemove(v, out ov);
            this.CheckReset();
        }
        public void Add(T item)
        {
            dict.TryAdd(_i, item);
            _i++;
        }
        public IEnumerable<T> Where(Func<T, bool> p)
        {
            return dict.Values.Where(p);
        }
        public T FirstOrDefault(Func<T, bool> p)
        {
            return dict.Values.Where(p).FirstOrDefault();
        }
        public bool Any(Func<T, bool> p)
        {
            return dict.Values.Where(p).Count() > 0 ? true : false;
        }
        public void Clear()
        {
            dict.Clear();
        }
        private void CheckReset()
        {
            if (dict.Count == 0)
            {
                this.Reset();
            }
        }
        private void Reset()
        {
            _i = 1;
        }
    }

Answer 15

使用lock 语句来执行此操作。 （阅读此处了解更多信息。 ）

private List<T> _list;

private List<T> MyT
{
    get { return _list; }
    set
    {
        //Lock so only one thread can change the value at any given time.
        lock (_list)
        {
            _list = value;
        }
    }
}

仅供参考，这可能并不完全符合您的要求 - 您可能想在代码中进一步锁定，但我不能这么认为。查看 lock 关键字并根据您的具体情况调整其使用。

如果需要，您可以使用 _list 变量在 get 和 set 块中锁定，这将使因此读/写不能同时发生。