线程同步和中止

Question

I've got a little problem with ending the work of one of my threads. First things first so here's the app "layout":

Thread 1 - worker thread (C++/CLI) - runs and terminates as expected

for(...)
{
  try
  {
    if(TabuStop) return;
    System::Threading::Monitor::Enter("Lock1");
    //some work, unmanaged code
  }
  finally
  {
    if(stop)
    {
      System::Threading::Monitor::Pulse("Lock1");
    }
    else
    {
      System::Threading::Monitor::Pulse("Lock1");
      System::Threading::Monitor::Wait("Lock1");
    }
  }
}

Thread 2 - display results thread (C#)

        while (WorkerThread.IsAlive)
        {
            lock ("Lock1")
            {
                if (TabuEngine.TabuStop)
                {
                    Monitor.Pulse("Lock1");
                }
                else
                {
                    Dispatcher.BeginInvoke(RefreshAction);

                    Monitor.Pulse("Lock1");
                    Monitor.Wait("Lock1", 5000);
                }

            }
           // Thread.Sleep(5000);
        }

I'm trying to shut the whole thing down from app main thread like this:

        TabuEngine.TabuStop = true; //terminates nicely the worker thread and 
        if (DisplayThread.IsAlive)
        {
            DisplayThread.Abort();
        }

I also tried using DisplayThread.Interrupt, but it always blocks on Monitor.Wait("Lock1", 5000); and I can't get rid of it. What is wrong here? How am I supposed to perform the synchronization and let it do the work that it is supposed to do?

//edit I'm not even sure now if the trick with using "Lock1" string is really working and locks are placed on the same object..

Answer 1

A nice example of producer / consumer synchronization using Monitors you can find on MSDN (Example 2) . There are two threads (producer and consumer, similar like in your case), but synchronization is done by introducing third class which locks shared resources. Example provides full source code, so I didn't post it here.

Answer 2

These are monitors, not auto reset or manual reset events. You need a condition to check to properly use wait. Otherwise, if you Pulse before you start waiting you will miss the the Pulse . Generally the pattern looks like:

Thread A:

 lock(x)
 {
    ... work ....
    while(!some_condition)
      Monitor.Wait(x)
 }

Thread B:

lock(x)
{
   ... other work ...
   some_condition = true;
   Monitor.Pulse(x)
}

By manipulating and checking some_condition with the lock held, we ensure that that no matter when the pulse happens (either before we start waiting in A or afterwards) A can always react appropriately and not wait forever for a pulse that already came.