SQL_Learner wrote:
Hello Tom,
Thanks for the program.
My actual problem is I have a block of code (shown below) which has a
critical section which is declared as static and this looks like a probable
thread safety issue as this might create 2 copies of critical sections. I am
looking for a alternative way to avoid this.
Here is the function
CKey* CKey::GetKey(void)
{
if (g_Key == NULL)
{
static CriticalSection cs(L"CKey::GetKey");
AutoLock lock(cs);
if ( g_Key == NULL)
{
static CKey key;
g_Key = &key;
}
}
return g_Key;
}
Do you think I can use the mechanism you explained for this case?
Your first problem is that you are using "double checked locking".
Google it to see why it is wrong on some architectures.
Your second problem you have identified - the initialization of cs is a
race condition.
To solve the problem using my functions, try this (I'm assuming g_Key is
a static member, basically a singleton?):
//library code:
#include <windows.h>
#include <sstream>
typedef LONG once_flag;
LONG const ONCE_FLAG_INIT = 0;
//this is an overload of the once function I posted before
//my original example accidentally named the 2 params the same!
void call_once(void (*f)(), once_flag& flag)
{
if (InterlockedCompareExchange(&flag, 1, 1) == 0)
{
std::owstringstream oss;
//missed L in line below in original example
oss << L"once_init_mutex_" << GetProcessId() << &f;
HANDLE mutex = CreateMutexW(NULL, TRUE, oss.str().c_str());
if (!mutex)
throw std::runtime_error("whatever");
if (GetLastError() == ERROR_ALREADY_EXISTS)
WaitForSingleObject(mutex, INFINITE);
if (flag == 0)
{
try
{
f();
}
catch(...)
{
ReleaseMutex(mutex);
CloseHandle(mutex);
throw;
}
flag = 1;
}
ReleaseMutex(mutex);
CloseHandle(mutex);
}
}
//end of library code
//static member function:
void CKey::InitKey()
{
static CKey key;
g_Key = &key;
}
//another static member function?
CKey* CKey::GetKey(void)
{
static once_flag flag = ONCE_FLAG_INIT;
call_once(&CKey::InitKey, flag);
return g_Key;
}
Untested of course, but let me know if you have any problems.
Tom