C#并发列表问题
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/1075492/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
C# Concurrent List Questions
提问by Matt H
I have a situation in C# where I have a list of simple types. This list can be accessed by multiple threads: entries can be added or removed, and the existence of an entry can be checked. I have encapsulated the list in an object exposing just those three operations so far.
我在 C# 中有一个情况，我有一个简单类型的列表。这个列表可以被多个线程访问：可以添加或删除条目，可以检查条目是否存在。到目前为止，我已经将列表封装在一个对象中，只公开这三个操作。
I have a few cases to handle (not exactly the same as the methods I just mentioned).
我有几个案例要处理（与我刚刚提到的方法不完全相同）。
- A thread can just check for the existence of an entry. (simple)
- A thread can check for the existence of an entry, and if it doesn't exist, add it.
- A thread needs to check whether an entry exists, and if it does, wait until it is removed.
- A combination of 2 and 3, where a thread checks for the existence of an entry, if it does exist, it must wait until it is removed before it can then add it itself.
- 一个线程可以只检查一个条目的存在。（简单的）
- 线程可以检查条目是否存在，如果不存在，则添加它。
- 一个线程需要检查一个条目是否存在，如果存在，等待它被删除。
- 2 和 3 的组合，其中一个线程检查一个条目是否存在，如果它确实存在，它必须等到它被删除，然后才能自己添加它。
The whole idea is that the existence of an entry signifies a lock. If an entry exists, the object it identifies cannot be changed and code cannot proceed because it is being modified elsewhere.
整个想法是一个条目的存在意味着一个锁。如果条目存在，则它标识的对象不能更改，代码也无法继续，因为它正在其他地方被修改。
These may seem like simple novice situations but I'm refreshing myself on concurrency issues and it's making me a bit paranoid, and I'm also not as familiar with C#'s concurrency mechanisms.
这些可能看起来像简单的新手情况，但我正在重新审视并发问题，这让我有点偏执，而且我也不熟悉 C# 的并发机制。
What would be the best way to handle this? Am I totally off? Should check and add (test and set?) be combined into a fourth atomic operation? Would I simply be adding lock blocks to my methods where the list is accessed?
处理这个问题的最佳方法是什么？我彻底没了？检查和添加（测试和设置？）应该合并到第四个原子操作中吗？我会简单地在访问列表的方法中添加锁块吗？
Also, is it possible to unit test this kind of thing (not the simple operations, the concurrency situations)?
另外，是否可以对这种事情进行单元测试（不是简单的操作，并发情况）？
采纳答案by Jon Skeet
Unit testing will certainly be hard.
单元测试肯定会很困难。
This can all be done reasonably simply with the "native" concurrency mechanisms in .NET: lock statements and Monitor.Wait/Monitor.PulseAll. Unless you have a separate monitor per item though, you're going to need to wake all the threads up whenever anything is removed - otherwise you won't be able to tell the "right" thread to wake up.
这一切都可以通过 .NET 中的“本机”并发机制来合理地完成：lock 语句和Monitor.Wait/ Monitor.PulseAll。除非您对每个项目都有一个单独的监视器，否则无论何时删除任何内容，您都需要唤醒所有线程 - 否则您将无法告诉“正确”线程唤醒。
If it really is just a setof items, you might want to use HashSet<T>instead of List<T>to represent the collection, by the way - nothing you've mentioned is to do with ordering.
如果它真的只是一组项目，那么您可能想要使用HashSet<T>而不是List<T>表示集合，顺便说一下 - 您提到的任何内容都与排序无关。
Sample code, assuming that a set is okay for you:
示例代码，假设一组适合您：
using System;
using System.Collections.Generic;
using System.Threading;
public class LockCollection<T>
{
private readonly HashSet<T> items = new HashSet<T>();
private readonly object padlock = new object();
public bool Contains(T item)
{
lock (padlock)
{
return items.Contains(item);
}
}
public bool Add(T item)
{
lock (padlock)
{
// HashSet<T>.Add does what you want already :)
// Note that it will return true if the item
// *was* added (i.e. !Contains(item))
return items.Add(item);
}
}
public void WaitForNonExistence(T item)
{
lock (padlock)
{
while (items.Contains(item))
{
Monitor.Wait(padlock);
}
}
}
public void WaitForAndAdd(T item)
{
lock (padlock)
{
WaitForNonExistence(item);
items.Add(item);
}
}
public void Remove(T item)
{
lock (padlock)
{
if (items.Remove(item))
{
Monitor.PulseAll(padlock);
}
}
}
}
(Completely untested, admittedly. You might also want to specify timeouts for the waiting code...)
（诚然，完全未经测试。您可能还想为等待代码指定超时......）
回答by JaredPar
While #1 may be the simplest to write, it's essentially a useless method. Unless you are holding onto the same lock after finishing a query for "existence of an entry", you are actually returning "existence of an entry at some point in the past". It doesn't give you any information about the current existence of the entry.
虽然#1 可能是最容易编写的，但它本质上是一种无用的方法。除非您在完成对“条目的存在”的查询后保持同一个锁，否则您实际上是在返回“过去某个时间点的条目的存在”。它不会为您提供有关条目当前存在的任何信息。
In between the discovery of a value in the list then doing any operation to retrieve, remove the value, another thread could come and remove it for you.
在发现列表中的一个值然后执行任何操作来检索、删除该值之间，另一个线程可能会来为您删除它。
Contains operations on a concurrent list should be combined with the operation you plan on doing in the case of true/false existence of that check. For instance TestAdd() or TestRemove() is muchsafer than Contains + Add or Contains + Remove
包含对并发列表的操作应与您计划在该检查存在真/假的情况下执行的操作相结合。例如TestAdd（）或TestRemove（）是多少安全比包含+添加或包含+删除
回答by Rytmis
There is a product for finding race conditions and suchlike in unit tests. It's called TypeMock Racer. I can't say anything for or against its effectiveness, though. :)
有一种用于在单元测试中查找竞争条件等的产品。它被称为TypeMock Racer。不过，我不能说任何赞成或反对它的有效性。:)
回答by Dean Chalk
here is a proper, concurrent, thread-safe, parallelisable concurrent list implementation http://www.deanchalk.me.uk/post/Task-Parallel-Concurrent-List-Implementation.aspx
这是一个适当的、并发的、线程安全的、可并行的并发列表实现 http://www.deanchalk.me.uk/post/Task-Parallel-Concurrent-List-Implementation.aspx
