Monitor.Enter 与 Monitor.Wait

Question

我仍然不确定这两个调用之间的区别。来自 MSDN，

Monitor.Enter(Object)获取指定对象的排他锁。

Monitor.Wait(Object) 释放对象上的锁并阻塞当前线程，直到它重新获得锁为止。

据此，我假设 Monitor.Wait 与 Monitor.Enter 相同，只是它在重新获取之前先释放对象上的锁定。

当前线程是否必须首先拥有锁？不同的线程如何强制释放对象的锁？为什么同一个线程要重新获取锁？

Answer 1

根据MSDN: Monitor.Wait Method(Object)

SynchronizationLockException：调用线程不拥有指定对象的锁。

换句话说：您只能在已经拥有锁时调用Monitor.Wait(Object)，而调用Monitor.Enter(Object)是为了获取锁。

至于为什么需要Monitor.Wait：如果您的线程意识到它缺少继续执行的信息（例如它正在等待信号），您可能希望让其他线程进入临界区，因为并非所有线程具有相同的先决条件。

要让等待的线程继续执行，您需要在释放锁之前调用Monitor.Pulse(Object) 或Monitor.PulseAll(Object) （否则，您将得到与Monitor.Wait(Object))。

请记住，在一个脉冲之后和释放锁之后获取锁的下一个线程不一定是接收到该脉冲的线程。

另外请记住，收到脉搏并不等于满足您的条件。您可能还需要再等一会儿：

// make sure to synchronize this correctly ;)
while (ConditionNotMet)
{
    Monitor.Wait(mutex);
    if (ConditionNotMet) // We woke up, but our condition is still not met
        Monitor.Pulse(mutex); // Perhaps another waiting thread wants to wake up?
}

Answer 2

考虑这个例子：

public class EnterExitExample
{
    private object myLock;
    private bool running;

    private void ThreadProc1()
    {
        while (running)
        {
            lock (myLock)
            {
                // Do stuff here...
            }
            Thread.Yield();
        }
    }

    private void ThreadProc2()
    {
        while (running)
        {
            lock (myLock)
            {
                // Do other stuff here...
            }
            Thread.Yield();
        }
    }
}

现在你有两个线程，每个线程都在等待锁，然后做自己的事情，然后释放锁。 lock (myLock) 语法只是 Monitor.Enter(myLock) 和 Monitor.Exit(myLock) 的糖。

现在让我们看一个更复杂的例子，Wait 和 Pulse 发挥作用。

public class PulseWaitExample
{
    private Queue<object> queue;
    private bool running;

    private void ProducerThreadProc()
    {
        while (running)
        {
            object produced = ...; // Do production stuff here.
            lock (queue)
            {
                queue.Enqueue(produced);
                Monitor.Pulse(queue);
            }
        }
    }

    private void ConsumerThreadProc()
    {
        while (running)
        {
            object toBeConsumed;
            lock (queue)
            {
                Monitor.Wait(queue);
                toBeConsumed = queue.Dequeue();
            }
            // Do consuming stuff with toBeConsumed here.
        }
    }
}

我们这里有什么？

生产者在他喜欢的时候就生产一个对象。一旦获得，他就获得了队列的锁定，将对象入队，然后调用Pulse。

同时，消费者没有锁，他通过调用Wait离开了它。一旦他在该对象上获得Pulse，他就会重新锁定，并做他消耗的事情。

所以你在这里得到的是一个直接的线程到线程通知，告诉消费者有什么事情要做。如果你不这样做，你所能做的就是让消费者继续对集合进行轮询，如果还有什么事情要做。使用Wait，可以确定有。

Answer 3

正如 Cristi 所说，幼稚的等待/脉冲代码不起作用。因为您完全错过了这里的关键点：监视器不是消息队列。如果您脉搏并且没有人在等待，则脉搏丢失。 正确的哲学是你在等待一个条件，如果条件不满足，有办法等待它，不吃cpu，不持有锁。在这里，消费者的条件是队列中有东西。 请参阅 https://ideone.com/tWqTS1 哪个有效（来自 Cristi 示例的一个分支）。

public class PulseWaitExample
{
    private Queue<object> queue;
    private bool running;

    private void ProducerThreadProc()
    {
        while (running)
        {
            object produced = ...; // Do production stuff here.
            lock (queue)
            {
                queue.Enqueue(produced);
                Monitor.Pulse(queue);
            }
        }
    }

    private void ConsumerThreadProc()
    {
        while (running)
        {
            object toBeConsumed;
            lock (queue)
            {
                // here is the fix
                if (queue.Count == 0)
                { 
                   Monitor.Wait(queue);
                }
                toBeConsumed = queue.Dequeue();
            }
            // Do consuming stuff with toBeConsumed here.
        }
    }
}