Synchronization Attribute and Monitor.Wait deadlock

[Chris Chilvers]

I've found the docs to be rather scant on exactly what the second parameter to WaitHandle.Wait One(Int32, Boolean) was
for. The one named exitContext so I started playing with the synchronize attribute to find out how it all works.

I'm puzzled at why this blocks until it times out.

What is supposed to happen is the consumer thread is started and waits for a producer to signal that something is ready.
This behavior is true if reEntrant == true.

What actually happens is that the consumer never releases its context lock on the object so the producer is unable to
enter the object whilst the consumer is waiting.

So what is the difference? Why can't Monitor.Wait release its lock on the context unless reEntrant == true?
class Program
{
public static void Main()
{
Tester test = new Tester();
Thread t1 = new Thread(new ThreadStart(tes t.Consume));
Thread t2 = new Thread(new ThreadStart(tes t.Produce));

t1.Start();

//ensure our consumer gets a lock and waits before starting the producer
Thread.Sleep(10 );
t2.Start();

t1.Join();
t2.Join();

Console.ReadKey (true);
}
}

//note: that reEntrant == false, if it's set to true there is no problem
[Synchronization (Synchronizatio nAttribute.REQU IRES_NEW, false)]
public class Tester : ContextBoundObj ect
{
private object resource_lock = new object();

//this method will not run on the second thread until the consumer times out and the first thread
//leaves the class (and thus the context).
public void Produce()
{
Console.WriteLi ne("Tester begin produce: ThreadId = " + Thread.CurrentT hread.ManagedTh readId);
lock (resource_lock)
{
//just pretend we are doing something then signal the consumer
Thread.Sleep(10 00);
Monitor.Pulse(r esource_lock);
}
Console.WriteLi ne("Tester end produce: ThreadId = " + Thread.CurrentT hread.ManagedTh readId);
}

public void Consume()
{
Console.WriteLi ne("Tester begin consume: ThreadId = " + Thread.CurrentT hread.ManagedTh readId);
lock (resource_lock)
{
//This will block indefinitely without the timeout, but should this not release the context?
if (Monitor.Wait(r esource_lock, 5000, true)) {
Console.WriteLi ne("Tester, Item consumed");
} else {
Console.WriteLi ne("Tester, TIMED OUT");
}
}
Console.WriteLi ne("Tester end consume: ThreadId = " + Thread.CurrentT hread.ManagedTh readId);
}
}
OUTPUT:
Tester begin consume: ThreadId = 4
Tester, TIMED OUT
Tester end consume: ThreadId = 4
Tester begin produce: ThreadId = 5
Tester end produce: ThreadId = 5

EXPECTED OUTPUT: (this behavior is exibited if reEntrant == true)
Tester begin consume: ThreadId = 4
Tester begin produce: ThreadId = 5
Tester end produce: ThreadId = 5
Tester, Item consumed
Tester end consume: ThreadId = 4