What is the problem with writing singleton in multithreaded enviroment

[Ronen Yacov]

Hi everybody,

When declaring a singleton, we write:

static CMySingle::instance()
{
static CMySingle instance;
return instance;
}

Why should there be a problem in a multithreaded enviroment?
If one thread creates a static object the other threads will have the
same
instance (becuase its static).

And if there is a problem, how the docuble check locking solves it?

 

[Milind]

What problem are you anticipating?? Is there something specific that
you are looking for. We use implementation which is pretty similar to
what you have quoted and it works fine with around 40 threads running
in the system.
Kindly, give more details.

~M

 

[robbies]

I did a little search of old group threads, and this popped up:
http://groups.google.com/group/comp...bbe602cde9d/fc1b524310a37e9e#fc1b524310a37e9e

The jist of it is, apparently, as the thread starter discovered, the
static construction of an object isn't an atomic operation. When it
gets compiled, it is turned into a set of instructions where a flag is
checked before the object is instantiated (which makes sense...I don't
know if the C++ Standard mentions whether it has to be done in the
certain way...I should look it up...). So if you think about it,
multiple threads could get past this check to instantiate the object,
which makes this not thread safe.

 

[u.int.32.t]

What problem are you anticipating?? Is there something specific that
you are looking for. We use implementation which is pretty similar to
what you have quoted and it works fine with around 40 threads running
in the system.
Kindly, give more details.

Your implementation will break on a SMP box. The correct (using
boost::call_once) is:

struct T
{
static T const & instance()
{
boost::call_once(&call_once,once_flag);
return get_instance();
}
private:
static boost:nce_flag once_flag;
static T const & get_instance()
{
static T theT;
return theT;
}

static void call_once()
{
get_instance();
}

};