使用两个不同线程的列表

在访问不同线程上的列表时，应始终使用lock。

 public class Sample
 {
     object synch = new object();
     List<Something> list = new List<Something>();
     void Add(Something something)
     {
        lock (synch) { list.Add(something); }
     }
     // Add the methods for update and delete.
  }

您应该将其封装在一个为您处理锁定的类中，或者使用线程安全集合，例如ConcurrentQueue<T>或System.Collections.Concurrent中的其他集合之一。

将同步对象暴露给公共API是危险的，并且不是一个好的做法。

首先，阅读这篇文章，了解它为什么不好：http://blogs.msdn.com/b/jaredpar/archive/2009/02/11/why-are-thread-safe-collections-so-hard.aspx

然后，像我一样做：

public abstract class ConcurrentCollection<T> : ICollection<T>
{
    private List<T> List { get; set; }
    public ConcurrentCollection()
    {
        this.List = new List<T>();
    }
    public T this[int index]
    {
        get
        {
            return this.List[index];
        }
    }
    protected virtual void AddUnsafe(T item)
    {
        this.List.Add(item);
    }
    protected virtual void RemoveUnsafe(T item)
    {
        this.List.Remove(item);
    }
    protected virtual void ClearUnsafe()
    {
        this.List.Clear();
    }
    public void Add(T item)
    {
        lock (this.List)
        {
            this.AddUnsafe(item);
        }
    }
    public bool Remove(T item)
    {
        lock (this.List)
        {
            this.RemoveUnsafe(item);
            return true;
        }
    }
    public void Clear()
    {
        lock (this.List)
        {
            this.ClearUnsafe();
        }
    }
    public int Count
    {
        get
        {
            lock (this.List)
            {
                return this.List.Count;
            }
        }
    }
    public bool IsReadOnly
    {
        get
        {
            return false;
        }
    }
    public bool Contains(T item)
    {
        lock (this.List)
        {
            return this.List.Contains(item);
        }
    }
    public void CopyTo(T[] array, int arrayIndex)
    {
        lock (this.List)
        {
            this.List.CopyTo(array, arrayIndex);
        }
    }
    public IEnumerator<T> GetEnumerator()
    {
        return new ConcurrentEnumerator<T>(this.List, this.List);
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        throw new NotImplementedException("Abstract concurrent enumerators not implemented.");
    }
}
public class ConcurrentEnumerator<T> : IEnumerator<T>
{
    private int Position = -1;
    private List<T> Duplicate;
    private object Mutex;
    private ICollection<T> NonConcurrentCollection;
    internal ConcurrentEnumerator(ICollection<T> nonConcurrentCollection, object mutex)
    {
        this.NonConcurrentCollection = nonConcurrentCollection;
        this.Mutex = mutex;
        lock (this.Mutex)
        {
            this.Duplicate = new List<T>(this.NonConcurrentCollection);
        }
    }
    public T Current
    {
        get
        {
            return this.Duplicate[this.Position];
        }
    }
    object IEnumerator.Current
    {
        get
        {
            return this.Current;
        }
    }
    public bool MoveNext()
    {
        this.Position++;
        lock (this.Mutex)
        {
            while (this.Position < this.Duplicate.Count && !this.NonConcurrentCollection.Contains(this.Current))
            {
                this.Position++;
            }
        }
        return this.Position < this.Duplicate.Count;
    }
    public void Reset()
    {
        this.Position = -1;
    }
    public void Dispose() { }
}
// Standards have List as derived Collection...
public class ConcurrentList<T> : ConcurrentCollection<T> { }

这段代码仍然不是完全安全的，例如Count示例可能仍然崩溃，但它允许跨线程进行迭代、添加和删除。如果您想公开互斥，那么就这样做，然后为您的其他代码构造(如count和contains(锁定它。

但这仍然是个坏主意。

编辑：示例用法。

ConcurrentList<string> list = new ConcurrentList<string>();
list.Add("hello");
list.Add("world");
list.Add("foo");
list.Add("bar");
foreach (string word in list)
{
    if (word == "world")
    {
        list.Remove("bar"); // Will not crash the foreach!
    }
    Console.WriteLine(word);
}

输出：

hello
world
foo