Re: Should I use mutex in this context?

swtbase@gmail.com wrote:


I'm going to play the devil's advocate here to argue that for this
SIMPLISTIC need, where one OWNER thread is the writer and the OTHERS
are readers only, then your synchronization needs are very low level,
and you don't need strong synchronization.

For precise synchronization, read Doug's and Ulrich's post.

However, my point is that these are FACTORS that are generally
transparent and applicable across the board, i.e, quantum ideas,
context switching, paging, memory delays, etc.

In fact, I would argue in this SIMPLISTIC CASE where you desire a
thread shutdown, you may not want any precise synchronization delays -
just THROW THE SWITCH and let the system act on it.

Again, note I said ONE OWNER WRITER THREAD and other READER threads.

What you probably more interested in is the final wait for thread
shutdown. Thats generally more important when considering "graceful
shutdowns" for simple cases like this.

Pseudo example:

  BOOL PoorManShutdownSignal = FALSE;

  void MyThreads()
  {
     while (!PoorManShutdownSignal) {
         .. thread loop ..
     }
  }

  int main()
  {
     Start Thread(s)

     .. Main Thread Loop ...

     PoorManShutdownSignal = TRUE << --- SEE NOTE 1!

     .. Wait For Thread(s) Completion using REAL
      synchronizations methods, i.e, waiting on the
      thread handles to close ...

     Done!
  }

NOTE 1: Who cares when that SIGNAL is read TRUE by other contexts!
As long as the main thread is waiting for the child threads to
complete, they will see the TRUE signal at some point.

That said, changing the PoorManShutdownSignal to a simple kernel
object semaphore, mutex, event (they are all semaphores derivatives)
is all you need to get thread synchronization precision.

--