Re: Efficient way to synchronize bool variables

From:

Goran <goran.pusic@gmail.com>

Newsgroups:

microsoft.public.vc.language,microsoft.public.vc.mfc

Date:

Wed, 11 Nov 2009 05:24:21 -0800 (PST)

Message-ID:

<afa09776-20d6-4538-aeae-ef2b82115581@s31g2000yqs.googlegroups.com>

On Nov 11, 1:09 pm, Faisal <faisal...@gmail.com> wrote:

In my program there are boolean vaiables which are shared between a
number of threads.

In the below code m_bRunning and m_bStopped are shared variables. The
function Execute() can be called from any of the threads.I want to
synchronize the accessing of the variable.

void OnStart()
{
        m_bStopped = false;
        m_bRunning = true;

}

void OnStop()
{
        m_bRunning = false;

}

void Execute()
{
        if( m_bRunning )
        {
                //Do some tasks
        }
        else
        {
                if( !m_bStopped )
                {
                        //Do some tasks
                        m_bStopped = true;
                }
        }

}

Does simply declaring the variables as volatile would solve my
problem?
Or do i need interlockedXXX functions here.

Volatile is all but useless on any hardware that has any form of CPU
cache.

InterlockedXXX are OK. I use a class similar to (warning: compiled and
tested with head-compiler):

class CThreadSafeFlag
{
  mutable LONG m_Flag;
public:
  CThreadSafeFlag(bool bSet=false) : m_Flag(bSet) {}
  bool IsSet() const { return InterlockedCompareExchange(&m_Flag, 2,
2) == true; }
  void Set() { InterlockedExchange(&m_Flag, 1); }
  void Reset() { InterlockedExchange(&m_Flag, 0); }
};

IsSet simply uses "impossible" exchange value to avoid changing
m_Flag, but still return it's value in a thread-safe manner.

Of course, this is all completely orthogonal to any race conditions I
might produce in rest of the code.

Goran.