多个线程等待一个事件？

Question

（我认为）我想要的是多个线程可以等待的 AutoResetEvent 的等价物，所有线程在设置后都会恢复。

我知道这可以通过每个线程有一个 AutoResetEvent 并设置每个线程来实现 - 但有更简单的方法吗？一种不依赖于事件句柄数组的方法？

实际上（我认为）我希望能够做到这一点：

private volatile string state;
private MultiEventHandle stateChanged = new MultiEventHandle();

public void WaitForBlob()
{
  while (true)
  {
    object saved = stateChanged.Current;  // some sentinel value
    if (state == "Blob") break;
    stateChanged.WaitTilNot(saved);  // wait til sentinel value != "current"
  }
}

public void SetBlob()
{
  state = "Blob";
  stateChanged.Change();  // stateChanged.Current becomes a new sentinel object
}

即任意数量的线程都可以调用 WaitForBlob，并且在任何时候（没有竞争条件）SetBlob code> 可以由另一个线程调用，并且所有等待线程将立即检测到更改 - 重要的是，没有自旋锁或 Threading.Sleeps。

现在我想我可以相对容易地实现“MultiEventHandle”。但我的问题是......有更好的方法吗？当然，我会犯这个错误，因为它一定是一个非常常见的用例，但我似乎找不到适合这项工作的内置工具。恐怕我可能要在这里发明一个方轮..

Answer 1

我在幕后使用 Monitor.PulseAll/Wait 将可能的解决方案包装到“WatchedVariable”类中（在此过程中了解了一些有关 Monitor 类的信息）。在此发布以防其他人遇到同样的问题 - 可能对不可变数据结构有一定用处。感谢乔恩·斯基特的帮助。

用法：

private WatchedVariable<string> state;

public void WaitForBlob()
{
  string value = state.Value;
  while (value != "Blob")
  {
    value = state.WaitForChange(value);
  }
}

实施：

public class WatchedVariable<T>
    where T : class
{
    private volatile T value;
    private object valueLock = new object();

    public T Value
    {
        get { return value; }
        set
        {
            lock (valueLock)
            {
                this.value = value;
                Monitor.PulseAll(valueLock);  // all waiting threads will resume once we release valueLock
            }
        }
    }

    public T WaitForChange(T fromValue)
    {
        lock (valueLock)
        {
            while (true)
            {
                T nextValue = value;
                if (nextValue != fromValue) return nextValue;  // no race condition here: PulseAll can only be reached once we hit Wait()
                Monitor.Wait(valueLock);  // wait for a changed pulse
            }
        }
    }

    public WatchedVariable(T initValue)
    {
        value = initValue;
    }
}

虽然它通过了我的测试用例，但使用风险自负。

现在咨询元来找出我应该接受哪个答案..

Answer 2

有什么理由不使用ManualResetEvent？当一个等待线程过去时，它不会自行重置，因此它们都会被释放。

当然，这意味着如果您需要在所有等待线程完成后重置事件，则需要某种方法来检测它。您可以可能使用信号量来代替，但我怀疑它会很复杂。

对于您的情况，您设置事件后是否需要立即重置事件？

Answer 3

我想出了一个不同的解决方案来解决这个问题。
它假设等待事件的线程在 WaitOne() 调用上不是紧密循环，并且等待调用之间有一些工作。
它使用一个 AutoResetEvent，连续调用 WaitOne(0) 和 Set()，直到没有其他线程等待该事件。

// the only event we'll use:
AutoResetEvent are = new AutoResetEvent(false);
// starting threads:
for (int i = 0; i < 10; i++)
{
    string name = "T" + i; 
    new Thread(() => { while (true) { are.WaitOne(); WriteLine(name); } }).Start();
}

// release all threads and continue:
while (!are.WaitOne(0))
    are.Set();

迭代的开销，当线程中的等待调用之间有更多工作时，可以轻松地将其限制为零。

上面的代码针对 1000 个线程进行了测试，它确实释放了所有线程（尽管 while 循环上有太多 从文档中我不清楚的是 Set() 是否可以释放稍后在同一线程上调用的 WaitOne() - 如果这种情况可能发生，那么此解决方案使用起来不安全，因为它可能不会在退出 while 循环之前释放所有线程。
如果有人能解释一下那就太好了。