help with threads communication

[BrownB]

Hello, I implemented a simlpe class CTimer, which launch a thread when Start() method is called which should exit when the Stop() method is called. The thread is a simple function with a while loop whose exit condition is m_bExitFlag == true:

class CTimer
{
public:
  CTimer();
  virtual ~CTimer();
  void Stop();
  void Start();
  ....

private:
  static UINT	privStartThreadWait( LPVOID pparam);
  BOOL		 m_bEndThread;		//true if stop is requested
  ....
}

The thread routine is this:

UINT CTimer::privStartThreadWait( LPVOID pparam)
{
	CTime		currTime;
	CTimeSpan	diffTime;
	CTimer		*pt;
	
	pt = (CTimer*)pparam;

	pt->m_bEndThread = false;
	pt->m_bThreadStopped = false;

	do
	{
		currTime = CTime::GetCurrentTime();
		diffTime = currTime - pt->m_startTime;
	}while( diffTime < pt->m_ctimTimeout && !pt->m_bEndThread );

	pt->m_bThreadStopped = true;
	AfxEndThread( 0 , true );

	return 0;
}

the Stop() method just sets m_bEndThread to true, and so the thread function should exit from the while() loop.

THE PROBLEM: the while() loop doesn't exit after I set m_bEndThread from the main thread, calling the Stop() method. I'd like to know if there si something I should know about the interprocess communication, as for example the kind of the members used to do the communication (perhaps should be public, or protected with caller class as friend, or static or something else).

Thank you for any hint.
BrownB

[grumpy]

Your information isn't really sufficient to be sure, but my guess is that making m_bEndThread volatile will fix the issue.

[BrownB]

thank you, I made the m_bEndThread boolean flag volatile, but this didn't help: in main thread, when I call CTimer::Stop() I set the m_bEndThread to true immediately, but the "child-thread" doesn't care and continues the loop. It only exits when the timeout is reached...

I found on CodeGuru an implementation for a simple timer class, and it looks exactly as mine...what's wrong? Compiler options? I'm using VC++ and MFC.

BrownB

[grumpy]

A few obvious possibilities I can think of.

1) Ensure the object you call Stop() for is the same as the one executing the thread.

2) Turn off compiler optimisation: it is possible that the compiler is optimising out the check of your m_bEndThread (although it's not the intent of volatile, I would have expected setting it volatile would address that).

3) Do things in a thread safe manner: introduce a critical section or mutex and protect accesses to the flag using that. Both the Stop() method and the thread method will need to use that protection.