Question

我觉得我应该知道答案，但无论如何我都会问，以防万一我犯了一个潜在的灾难性错误。

以下代码按预期执行，没有错误/异常：

static void Main(string[] args)
{
    ManualResetEvent flag = new ManualResetEvent(false);
    ThreadPool.QueueUserWorkItem(s =>
    {
        flag.WaitOne();
        Console.WriteLine("Work Item 1 Executed");
    });
    ThreadPool.QueueUserWorkItem(s =>
    {
        flag.WaitOne();
        Console.WriteLine("Work Item 2 Executed");
    });
    Thread.Sleep(1000);
    flag.Set();
    flag.Close();
    Console.WriteLine("Finished");
}

当然，正如多线程代码的情况一样，成功的测试并不能证明这实际上是线程安全的。如果我将Close放在Set之前，测试也会成功，即使文档明确指出在Close之后尝试执行任何操作都会导致未定义的行为。

我的问题是，当我调用ManualResetEvent.Set方法时，是否保证在将控制权返回给调用方之前发出所有等待线程的信号？换句话说，假设我能够保证不会再调用WaitOne，这里关闭句柄是否安全，或者在某些情况下这个代码可能会阻止一些服务员收到信号或导致ObjectDisposedException？

文档只说Set将其置于“信号状态” - 它似乎没有声称服务员何时会实际上发出信号，所以我'我想确定一下。

Answer 1

当您使用ManualResetEvent.Set发信号时，您可以确保在将控制权返回给调用者之前，将发出等待该事件的所有线程（即flag.WaitOne处于阻塞状态）的信号。< / p>

当然，在某些情况下你可能会设置标志并且你的线程没有看到它，因为它在检查标志之前正在做一些工作（或者如果你创建多个线程则建议使用nobugs）：

ThreadPool.QueueUserWorkItem(s =>
{
    QueryDB();
    flag.WaitOne();
    Console.WriteLine("Work Item 1 Executed");
});

标志上存在争用，现在您可以在关闭它时创建未定义的行为。您的标志是线程之间的共享资源，您应该创建一个倒计时锁存器，每个线程在完成后发出信号。这样可以消除flag上的争用。

public class CountdownLatch
{
    private int m_remain;
    private EventWaitHandle m_event;

    public CountdownLatch(int count)
    {
        Reset(count);
    }

    public void Reset(int count)
    {
        if (count < 0)
            throw new ArgumentOutOfRangeException();
        m_remain = count;
        m_event = new ManualResetEvent(false);
        if (m_remain == 0)
        {
            m_event.Set();
        }
    }

    public void Signal()
    {
        // The last thread to signal also sets the event.
        if (Interlocked.Decrement(ref m_remain) == 0)
            m_event.Set();
    }

    public void Wait()
    {
        m_event.WaitOne();
    }
}

每个线程在倒计时锁存器上发出信号。
您的主线程在倒计时锁定器上等待。
倒计时锁存信号后主线程清零。

最终，你最后一次睡觉的时间并不是解决问题的安全方法，而是应该设计你的程序，使其在多线程环境中100％安全。

更新：单一生产者/多个消费者
~~这里的假设是你的生产者知道将创建多少消费者，~~在你创建所有消费者之后，你用给定数量的消费者重置CountdownLatch：

// In the Producer
ManualResetEvent flag = new ManualResetEvent(false);
CountdownLatch countdown = new CountdownLatch(0);
int numConsumers = 0;
while(hasMoreWork)
{
    Consumer consumer = new Consumer(coutndown, flag);
    // Create a new thread with each consumer
    numConsumers++;
}
countdown.Reset(numConsumers);
flag.Set();
countdown.Wait();// your producer waits for all of the consumers to finish
flag.Close();// cleanup

Answer 2

不行。你在这里很幸运，因为你只开始了两个主题。当你在双核机器上调用Set时，它们会立即开始运行。试试这个并观看炸弹：

    static void Main(string[] args) {
        ManualResetEvent flag = new ManualResetEvent(false);
        for (int ix = 0; ix < 10; ++ix) {
            ThreadPool.QueueUserWorkItem(s => {
                flag.WaitOne();
                Console.WriteLine("Work Item Executed");
            });
        }
        Thread.Sleep(1000);
        flag.Set();
        flag.Close();
        Console.WriteLine("Finished");
        Console.ReadLine();
    }

当旧计算机或当前计算机忙于处理其他任务时，原始代码将类似地失败。

Answer 3

我认为存在竞争条件。根据条件变量编写事件对象后，您将得到如下代码：

mutex.lock();
while (!signalled)
    condition_variable.wait(mutex);
mutex.unlock();

因此，当事件可能发出信号时，等待事件的代码可能仍需要访问事件的某些部分。

根据Close上的文档，这只会释放非托管资源。因此，如果活动仅使用托管资源，您可能会很幸运。但是这可能会在未来发生变化，所以我会在预防措施方面犯错误，直到你知道不再使用该事件为止。

Answer 4

对我来说看起来像一个冒险的模式，即使由于[当前]实施，也没关系。您正在尝试处置可能仍在使用的资源。

就像在新对象和构建对象之前，即使在该对象的消费者完成之前也盲目地删除它。

即便如此，这里也有problem。即使在其他线程有机会运行之前，程序也可能会退出。线程池线程是后台线程。

鉴于你必须等待其他线程，你也可以事后清理。

发信号并立即关闭ManualResetEvent是否安全？

4 个答案: