线程安全的 List<T> 属性

Question

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

类似这样的：

private List<T> _list;

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

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

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

Answer 1

使用lock 语句来执行此操作。 (Read here for more information.)

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 关键字并根据您的具体情况调整其用法。

如果需要，您可以在 get 和 set 块中使用 _list 变量，这将使其不会同时发生读/写操作。

Answer 2

如果您的目标是 .Net 4，System.Collections.Concurrent 命名空间中有几个选项

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

Answer 3

基本上如果要安全枚举，就需要使用lock。

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

这是您可能感兴趣的 MSDN 的一部分：

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

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

Answer 4

我相信_list.ToList() 会给你一个副本。如有需要也可以查询如：

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

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

Answer 5

我认为制作一个示例 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 6

你也可以使用更原始的

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

使用哪个锁（见这篇帖子C# Locking an object that is reassigned in lock block）。

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

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 7

即使它获得了最多的选票，通常也不能将System.Collections.Concurrent.ConcurrentBag<T> 作为System.Collections.Generic.List<T> 的线程安全替代品，因为它（Radek Stromský 已经指出）没有被订购。

但是有一个名为 System.Collections.Generic.SynchronizedCollection<T> 的类自 .NET 3.0 起就已成为框架的一部分，但它隐藏得很好偶然发现它（至少我从未这样做过）。

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

Answer 8

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

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

Answer 9

C# 的ArrayList 类有一个Synchronized 方法。

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

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

Answer 10

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

   [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 11

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

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

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

Answer 12

我建议任何在多线程场景中处理List<T> 的人查看Immutable Collections，尤其是ImmutableArray。

我发现它非常有用：

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

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

Answer 13

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

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

查看原始示例可能会猜到其意图是能够简单地用新列表替换列表。属性的 setter 告诉我们。

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

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

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

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

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