Re: Should I use mutex in this context?

From:

"Ben Voigt [C++ MVP]" <rbv@nospam.nospam>

Newsgroups:

microsoft.public.vc.language

Date:

Wed, 29 Oct 2008 14:31:30 -0500

Message-ID:

<e7FjyzfOJHA.1576@TK2MSFTNGP06.phx.gbl>

Tommy wrote:

swtbase@gmail.com wrote:

Hi,
My program has two threads; one main thread and other working thread.
My main thread asks the worker thread to terminate if system is
shutting down by making true a boolean value which is a global shared
resource. The main thread only writes to the global value and the
worker thread only reads the same value. In this context, is mutex
use necessary?

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 ..
    }

Trouble is, the compiler sees that PoorManShutdownSignal is not modified
inside the loop, so it optimizes this to:

    if (!PoorManShutdownSignal) {
        do {
            ...
        } while (true);
    }

}

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.