Re: singleton in a DLL loaded class
On Jun 25, 1:07 pm, ampar...@gmail.com wrote:
On Jun 25, 10:57 am, PaulH <paul.h...@gmail.com> wrote:
I have a class loaded from a DLL that I would like to implement as a
multi-threadable singleton. Unfortunately, I seem to still be getting
two distinct instances of this class. It is implemented as below.
The only funny thing I am doing is to load the DLL from two threads
simultaneously (thus the need for the singleton). But, according to
other posts I've read, the OS will point them both to the same
instance of the DLL so that only one thread actually loads the DLL.
If the two threads are from the same process, then there will be only
one instance of the DLL.
Having said that, even if the threads are from different process with
each process having different instanced of the DLL, you need to
synchronize to have one unique instance of the class.
Can anybody point out where I may be going wrong?
Thanks,
PaulH
//singletonclass.h
class SingletonClass : BaseClass
{
public:
static SingletonClass& Instance();
~SingletonClass();
//... Implement BaseClass functions
private:
static std::auto_ptr< SingletonClass > _theInstance;
static Mutex* _m;
}
//singletonclass.cpp
std::auto_ptr< SingletonClass > SingletonClass::_theInstance;
Mutex* SingletonClass::_m;
/*static*/ SingletonClass& SingletonClass::Instance()
{
Mutex::Create( &_m );
_m->lock();
if( _theInstance.get() == NULL )
_theInstance.reset( new SingletonClass() );
_m->unlock();
return *_theInstance;
}
//dll.cpp
MY_API BaseClass* Create()
{
return &SingletonClass::Instance();
}- Hide quoted text -
- Show quoted text -
Looks ok though one thing I cannot know is you implementation of
Mutex class ? How are you implementing it internally ? Are you
implementing it as a Critical Section or as Regular Mutex ? Because
Critical Section guarentees synchonization only within a process and
not across processes and so if your threads are from different
processes, then there could be a problem.
This only needs to work between threads of a single process. I didn't
realize the difference between the CS and the Mutex. I have it
implemented as below as a CS, so the "Mutex" name is a misnomer.
-Paul
class Mutex
{
public:
static HRESULT Create( Mutex** ppMutex )
{
Mutex *pMutex = new Mutex();
if( !pMutex )
{
return E_OUTOFMEMORY;
}
if( !InitializeCriticalSectionAndSpinCount( &pMutex->_cs,
0 ) )
{
HRESULT hr = HRESULT_FROM_WIN32( GetLastError() );
delete pMutex;
return hr;
}
pMutex->_Initialized = TRUE;
*ppMutex = pMutex;
pMutex = NULL;
return S_OK;
};
~Mutex()
{
if( this->_Initialized )
DeleteCriticalSection( &this->_cs );
};
void lock()
{
EnterCriticalSection( &this->_cs );
};
void unlock()
{
LeaveCriticalSection( &this->_cs );
};
private:
Mutex(){};
CRITICAL_SECTION _cs;
BOOL _Initialized;
};