ManualResetEvent - WaitOne() 似乎在某些时候没有释放线程

Question

我有一个多线程表单应用程序，这就是相关部分的设计方式：

线程 2（BatchPreviewAssistant 类）正在等待主界面线程传递图像加载任务。接收到任务后，BatchPreviewAssistant 会将任务分配给 N=5 等待的 PrimaryLoader 线程并启用它们。 PrimaryLoaders 使用 2 个手动重置事件启动/停止无限循环：_startEvent 和 _endEvent。此外，还有一个包含 N 个手动重置事件 _parentSyncEvent 的数组，用于从 PrimaryLoaders 向 BatchPreviewAssistant 发出处理结束信号。

所以通常每个 PrimaryLoader 都在 _startEvent.WaitOne() 处等待。 一旦 BatchPreviewAssistant 需要激活它们并运行 RunPrimaryLoaders()，它会首先重置 _endEvent 和 _parentSyncEvents，然后设置 _startEvent。现在它阻塞在 WaitHandle.WaitAll(_parentSyncEvents _startEvent.Set() 导致所有 PrimaryLoader 继续进行。 每个 PrimaryLoader 完成后，就会在 _parentSyncEvent 中设置自己的事件，直到所有 5 个事件都设置完毕。此时所有 PrimaryLoader 都到达 _endEvent.WaitOne() 并等待。现在 _parentSyncEvents 已全部设置完毕，这使得 BatchPreviewAssistant 能够继续。 BatchPreviewAssistant 重置 _startEvent，然后设置 _endEvent，这将释放 PrimaryLoaders，然后它们返回到循环的开头。

BatchPreviewAssistant：

    private void RunPrimaryLoaders()
    {
        BatchPreviewThreadsLogger.WriteLog(Common.LogLevel.Debug1, "RunPrimaryLoaders()");
        ResetEvents(_parentSyncEvents);
        _endEvent.Reset();
        _startEvent.Set();

        // Primary Loader loops restart

        BatchPreviewThreadsLogger.WriteLog(Common.LogLevel.Debug2, "WaitHandle.WaitAll(_parentSyncEvent");
        if (!WaitHandle.WaitAll(_parentSyncEvents, 20 * 1000))
        {
            throw new TimeoutException("WaitAll(_parentSyncEvent) in ProcessCurrentCommand");
            // TODO: Terminate?
        }
        BatchPreviewThreadsLogger.WriteLog(Common.LogLevel.Message3, "Primary loading is complete");
        _startEvent.Reset();
        _endEvent.Set();
        bool isEndEventSet = _endEvent.WaitOne(0);
        BatchPreviewThreadsLogger.WriteLog(Common.LogLevel.Debug2, "isEndEventSet?" + isEndEventSet.ToString());
    }

PrimaryLoader：

    public void StartProc(object arg)
    {
        while (true)
        {
            BatchPreviewThreadsLogger.WriteLog(Common.LogLevel.Debug2, "Primary Loader: _startEvent.WaitOne()");
            _startEvent.WaitOne();

            try
            {
                BatchPreviewThreadsLogger.WriteLog(Common.LogLevel.Message4, "Primary Loader is processing entry:" + processingEntry.DisplayPosition.ToString());
            }
            catch (Exception ex)
            {
                BatchPreviewThreadsLogger.WriteLog(Common.LogLevel.Error, "Exception in PrimaryImageLoader.StartProc:" + ex.ToString());
            }
            _parentSyncEvent.Set();
            BatchPreviewThreadsLogger.WriteLog(Common.LogLevel.Debug2, "Primary Loader: _endEvent.WaitOne()");
            _endEvent.WaitOne();
        }
    }

此代码可以很好地生成数百个这样的循环，但我偶尔会遇到问题，特别是在压力测试期间。发生的情况是，当 BatchPreviewAssistant 设置 _endEvent.Set() 时，在 _endEvent.WaitOne() 处没有释放任何 PrimaryLoader；您可以看到我检查了 BatchPreviewAssistant 并看到该事件确实已设置，但 PrimaryLoaders 并未释放。

[10/27/2011;21:24:42.796;INFO ] [42-781:16]Primary Loader: _endEvent.WaitOne()
[10/27/2011;21:24:42.796;INFO ] [42-781:18]Primary Loader: _endEvent.WaitOne()
[10/27/2011;21:24:42.796;INFO ] [42-781:19]Primary Loader: _endEvent.WaitOne()
[10/27/2011;21:24:42.843;INFO ] [42-843:15]Primary Loader: _endEvent.WaitOne()
[10/27/2011;21:24:42.937;INFO ] [42-937:17]Primary Loader: _endEvent.WaitOne()
[10/27/2011;21:24:42.937;INFO ] [42-937:14]Primary loading is complete
[10/27/2011;21:24:42.937;INFO ] [42-937:14]isEndEventSet?True

这种设计是否存在任何可能导致该问题的明显问题？ 我可以看到一些尝试解决问题的方法，但是很高兴看到这种方法有什么问题。

以防万一，我还提供了有关初始化和启动 PrimaryLoaders 的方式的信息。

private PrimaryImageLoader[] _primaryImageLoaders;

_primaryImageLoaders = new PrimaryImageLoader[N]

for (int i = 0; i < _primaryImageLoaderThreads.Length; i++)
{
  _parentSyncEvents[i] = new AutoResetEvent(false);
  _primaryImageLoaders[i] = new PrimaryImageLoader(i, _parentSyncEvents[i], 
      _startEvent, _endEvent,
      _pictureBoxes, _asyncOperation,
      LargeImagesBufferCount);
  _primaryImageLoaderThreads[i] = new Thread(new ParameterizedThreadStart(_primaryImageLoaders[i].StartProc));
  _primaryImageLoaderThreads[i].Start();
}

请注意，为了简化添加的示例，一些不相关的代码已被删除

： 我同意该示例太繁忙且难以遵循。简而言之：

Thread 2:
private void RunPrimaryLoaders()
{
  _endEvent.Reset();
  _startEvent.Set();

  _startEvent.Reset();
  _endEvent.Set();
  bool isEndEventSet = _endEvent.WaitOne(0);
}

Threads 3-7:
public void StartProc(object arg)
{
  while (true)
  {
    _startEvent.WaitOne();

    _endEvent.WaitOne();     // This is where it can't release occasionally although Thread 2 checks and logs that the event is set
  }
}

Answer 1

这种设计是否存在任何可能导致该问题的明显问题？

当你试图做一件简单的事情时，你似乎想出了一个非常复杂的设计。看起来简单的生产者/消费者模式会工作得更好，并且您不必处理手动重置事件的灾难。

您可能想要更多类似的内容：

class Producer
{
    private readonly BlockingQueue<Task> _queue;

    public Producer(BlockingQueue<Task> queue)
    {
        _queue = queue;
    }

    public LoadImages(List<Task> imageLoadTasks)
    {
        foreach(Task t in imageLoadTasks)
        {
            _queue.Enqueue(task);
        }
    }
}

class Consumer
{
    private volatile bool _running;
    private readonly BlockingQueue<Task> _queue;

    public Consumer(BlockingQueue<Task> queue)
    {
        _queue = queue;
        _running = false;
    }

    public Consume()
    {
        _running = true;

        while(_running)
        {
            try
            {
                // Blocks on dequeue until there is a task in queue
                Task t = _queue.Dequeue();

                // Execute the task after it has been dequeued
                t.Execute();
            }
            catch(ThreadInterruptedException)
            {
                // The exception will take you out of a blocking
                // state so you can check the running flag and decide
                // if you need to exit the loop or if you shouldn't.
            }
        }
    }
}

因此，您必须在单独的线程上运行每个“Producer”实例，并且也必须在其自己的线程上运行每个“Consumer”实例。当然，您必须添加所有附加功能才能优雅地终止它们，但那是另一回事了。

Answer 2

你有一个竞争条件。如果您的逻辑是检测到一个条件，将一个事件设置为阻止，然后等待该事件，则必须有一个干预解锁。

您的代码执行以下操作：

1. 决定等待

2. 将事件设置为阻止

3. 等待事件

如果发生以下情况，则会出现问题该事件发生在步骤1和2之间。当我们将事件设置为阻塞时，该事件可能已经发生并解除了该事件的阻塞。当我们到达步骤 3 时，我们正在等待一个已经发生的事件来解锁它已经解锁的对象。坏的。

修复如下：

1. 获取锁

2. 我们需要等待吗？如果不是，释放锁并返回

3. 将事件设置为阻塞

4. 释放锁

5. 等待事件

因为我们持有一个现在锁定，在我们决定等待和将事件设置为阻止之间，事件不能发生。当然，解锁事件的代码在执行处理事件和解锁事件的逻辑时必须持有相同的锁。