Re: Singleton_pattern and Thread Safety

From:

Leigh Johnston <leigh@i42.co.uk>

Newsgroups:

comp.lang.c++

Date:

Sat, 11 Dec 2010 02:23:10 +0000

Message-ID:

<xOWdnRi90KgVfZ_QnZ2dnUVZ8r2dnZ2d@giganews.com>

On 10/12/2010 23:31, Ian Collins wrote:

On 12/11/10 10:08 AM, Leigh Johnston wrote:

On 10/12/2010 20:39, Ian Collins wrote:

On 12/11/10 09:21 AM, Leigh Johnston wrote:

Not considering object destruction when designing *new* classes is bad
practice IMO. Obviously there may be problems when working with
pre-existing designs which were created with a lack of such
consideration.

A programmer seldom has the benefit of a green field design. Even when
he or she does, there are still the dark and scary corners of the
language where undefined behaviour lurks. Order of destruction issues is
one such corner, especially when static objects exist in multiple
compilation units.

I am well aware of the unspecified construction/destruction order
associated with globals in multiple TUs and that is primary reason why
this method of James's should be avoided. The order of destruction of
"Meyers Singleton" objects *is* well defined for example although making
the "Meyers Singleton" method thread safe is not completely trivial.

That is another pattern I use, but as you say, it has issues of its own.

Normally I instantiate all my singletons up front (before threading) but
I decided to quickly roll a new singleton template class just for the
fun of it (thread-safe Meyers Singleton):

namespace lib
{
    template <typename T>
    class singleton
    {
    public:
        static T& instance()
        {
            if (sInstancePtr != 0)
                return static_cast<T&>(*sInstancePtr);
            { // locked scope
                lib::lock lock1(sLock);
                static T sInstance;
                { // locked scope
                    lib::lock lock2(sLock); // second lock should emit memory barrier here
                    sInstancePtr = &sInstance;
                }
            }
            return static_cast<T&>(*sInstancePtr);
        }
    private:
        static lib::lockable sLock;
        static singleton* sInstancePtr;
    };

    template <typename T>
    lib::lockable singleton<T>::sLock;
    template <typename T>
    singleton<T>* singleton<T>::sInstancePtr;
}

/Leigh