Let me test your threading prowess. The previous listing contained a race condition. Can you find it? Take a minute or two before continuing. Tic! Tic! Tic!

A race condition is a bug caused by an incorrect assumption as to the timing of two events, that is, that one event would always occur before the other. The race condition occurs when the system shuts down. If the main thread is swapped out in the Wait instance method between testing if the queue length is zero and setting the WaitForComplete flag to true and then the last consuming thread exits the Consume instance method while the main thread is in this state, the event will never be triggered. I ran the code a few hundred times and was never able to trigger the condition. You can't reproduce it because the main thread should be waiting on the event object well before the last consuming-thread exits.

Monitor and Lock

I could have arranged the code otherwise to prevent this race condition, but now I've created another opportunity to introduce you to the System. Threading. Monitor class and the lock C# construct. The monitor design pattern is most familiar to Java developers. In Java, the synchronized keyword allowed the developer to create quick critical sections within their code. The Java construct was often called a monitor.

The .NET framework presents a similar class called the Monitor that implements traditional wait and signal methods called Wait and Pulse. The C# compiler uses this Monitor class to implement a language construct called a lock. The lock is established on an object and while the lock is established, nobody else can acquire the lock and must wait till the lock is freed. I used this lock construct to prevent our previous race condition (see Listing 4).

public void Wait()
{
    lock (this)
    {
        if (QueueLength == 0)
        {
            return;
        }
        Event = new ManualResetEvent(false);
        WaitForComplete = true;
    }
    Event.WaitOne();
}

public void Consume(Object obj)
{
    Console.WriteLine("Thread {0} consumes {1}",
        Thread.CurrentThread.GetHashCode(), //{0}
        ((Ware) obj).id); //{1}
    Thread.Sleep(100);
    lock (this)
    {
        QueueLength--;
        if (! WaitForComplete)
        {
            return;
        }
    }
    if (QueueLength == 0)
    {
        Event.Set();
    };
}

Preventing the concurrent setting and testing of the queue length and WaitForComplete flag by two different threads removes the race condition. The lock ensures that the setting and testing of these two variables is essentially atomic.