Is this Singleton class thread-safe?

Hello

I have written a singleton class like this:

//---------------------------------------------------------------------------
// Instance
//---------------------------------------------------------------------------
template <typename T>
T * CSingleton<T>::Instance(
) throw()
{
static T inst;
return &inst;
}

Is this thread safe? Could two threads (with cpu context switching)
possibly create more than one instance of the class passed as a
template? Is this possible? If it is I presume I must lock using
mutex or some mechanism before line - static T inst; and just after
it?

Angus napisał(a):

>Hello

I have written a singleton class like this:

//---------------------------------------------------------------------------

// Instance
//---------------------------------------------------------------------------

template <typename T>
T * CSingleton<T>::Instance(
) throw()
{
static T inst;
return &inst;
}

Is this thread safe? Could two threads (with cpu context switching)
possibly create more than one instance of the class passed as a
template? Is this possible? If it is I presume I must lock using
mutex or some mechanism before line - static T inst; and just after
it?

It is not thread safe and you must lock it, however mutex lock might
give performace penalty - depends on yours app. There is something
called double-checking locking - google for that - it's well known and
described problem

DJ wrote:

>Angus napisał(a):

>>Hello

I have written a singleton class like this:

//---------------------------------------------------------------------------

// Instance
//---------------------------------------------------------------------------

template <typename T>
T * CSingleton<T>::Instance(
) throw()
{
static T inst;
return &inst;
}

Is this thread safe? Could two threads (with cpu context switching)
possibly create more than one instance of the class passed as a
template? Is this possible? If it is I presume I must lock using
mutex or some mechanism before line - static T inst; and just after
it?

It is not thread safe and you must lock it, however mutex lock might
give performace penalty - depends on yours app. There is something
called double-checking locking - google for that - it's well known and
described problem

Some compilers do make sure it's thread safe (see G++ past V4).

>
DCL (double checked locking) is not considered a good thing because it
does not work on all machines - see past articles on
comp.programing.threads.

I am just thinking if you call ::Instace before threads are created in
the app you should be fine as the static object must be created,
shoudn't you ?

>>
DCL (double checked locking) is not considered a good thing because it
does not work on all machines - see past articles on
comp.programing.threads.

true.