Should I just make the thread a background thread?  Or should I pass a
dummy object to ProducerConsumer.Produce to make Consume return?  Or is
there a better way?

| public class ProducerConsumer
| {
|     readonly object listLock = new object();
|     Queue queue = new Queue();
|
|     public void Produce(object o)
|     {
|         lock (listLock)
|         {
|             queue.Enqueue(o);
|             if (queue.Count==1)
|             {
|                 Monitor.Pulse(listLock);
|             }
|         }
|     }
|    
|     public object Consume()
|     {
|         lock (listLock)
|         {
|             while (queue.Count==0)
|             {
|                 Monitor.Wait(listLock);
|             }
|             return queue.Dequeue();
|         }
|     }
| }

--
Jon Skeet - <sk...@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

 public class ProducerConsumer
 {
     readonly object listLock = new object();
     Queue queue = new Queue();
+    volatile bool stopped = false;

     public void Produce(object o)
     {
         lock (listLock)
         {
             queue.Enqueue(o);
             if (queue.Count==1)
             {
                 Monitor.Pulse(listLock);
             }
         }
     }

     public object Consume()
     {
         lock (listLock)
         {
-            while (queue.Count==0)
+            while (queue.Count==0 && !stopped)
             {
                 Monitor.Wait(listLock);
             }
-            return queue.Dequeue();
+            return stopped ? null : queue.Dequeue();
         }
     }

+    public void Stop()
+    {
+        stopped = true;
+        Monitor.Pulse(listLock);
+    }
 }

I believe that making stopped *volatile* should make it thread-safe here..?

You'd need to make sure the consumer knew that null meant "the queue
might have stopped" of course. (You would probably want to expose the
stopped flag as a public property too, just in case you ever wanted to
*actually* produce a null.)

--
Jon Skeet - <sk...@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

Thanks for your help!

Argh!  I can't get it to work!

I get an exception when I try to call ProducerConsumer.Stop:

    An unhandled exception of type
    'System.Threading.SynchronizationLockException' occurred in
    mscorlib.dll

    Additional information: Object synchronization method was called from
    an unsynchronized block of code.

I can't see how to get around this.

Full code:

using System;
using System.Collections;
using System.Threading;

public class Test
{
    static ProducerConsumer queue = new ProducerConsumer();

    static void Main()
    {
        new Thread(new ThreadStart(ConsumerJob)).Start();

        queue.Produce(new object());
        Thread.Sleep(2000);
        queue.Stop();
    }

    static void ConsumerJob()
    {
        while (!queue.Stopped)
        {
            object o = queue.Consume();
            Console.WriteLine("Consuming {0}.", o);
        }
    }

    public bool Stopped
    {
        get { return stopped; }
    }

    public void Produce(object o)
    {
        lock (listLock)
        {
            queue.Enqueue(o);
            if (queue.Count==1)
            {
                Monitor.Pulse(listLock);
            }
        }
    }

    public object Consume()
    {
        lock (listLock)
        {
            while (queue.Count==0 && !stopped)
            {
                Monitor.Wait(listLock);
            }
            return stopped ? null : queue.Dequeue();
        }
    }

    public void Stop()
    {
        stopped = true;
        Monitor.Pulse(listLock);
    }

lock (listLock)
{
    Monitor.Pulse (listLock);

--
Jon Skeet - <sk...@pobox.com>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too