原子列表 - 这个集合线程安全且快速吗？

Question

我正在尝试找出最好的方法来拥有一个集合，我将能够同时从不同的线程中迭代、添加项目和删除所有项目。性能对于迭代组件至关重要，但不会经常添加和删除项目 - 因此添加/删除性能稍微不那么重要。

这是我想出的：

public class AtomicList<T> : IEnumerable<T>
{
    private readonly object Locker = new object();
    private List<T> InternalCollection = new List<T>();

    public void Add(T Value)
    {
        lock (Locker)
        {
            List<T> Update = new List<T>(InternalCollection);
            Update.Add(Value);
            InternalCollection = Update;
        }
    }

    public void Remove(T Value)
    {
        lock (Locker)
        {
            List<T> Update = new List<T>(InternalCollection);
            Update.Remove(Value);
            InternalCollection = Update;
        }
    }

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

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

这样做有什么缺点吗？会不会像我上面描述的那样是线程安全/可迭代的？

另外 - 使用 foreach 和 IEnumerable 是否有任何性能成本？如果我直接访问 InternalCollection 并对其进行 for 语句会更好吗？

Answer 1

如果您不同时调用 Add 和 Remove 方法，则不需要 locks，因为您只是从 InternalCollection 字段引用的列表中读取。使用Interlocked.Exchange Method 以线程安全的方式将旧列表替换为新列表：

public class AtomicList<T> : IEnumerable<T>
{
    private List<T> internalCollection = new List<T>();

    public void Add(T vlue)
    {
        List<T> update = new List<T>(internalCollection);
        update.Add(value);
        Interlocked.Exchange(ref internalCollection, update);
    }

    public bool Remove(T value)
    {
        List<T> update = new List<T>(internalCollection);
        bool removed = update.Remove(value);
        if (removed) Interlocked.Exchange(ref internalCollection, update);
        return removed;
    }

    public IEnumerator<T> GetEnumerator()
    {
        ...