Re: [Boost-users] thread safety of the mutex ctor

19 Aug 2005

      On 18/08/2005, at 8:04 AM, boost-users-request@lists.boost.org wrote:
...
On 8/17/05, Christopher Hunt  wrote:
...
On 18/08/2005, at 1:19 AM, boost-users-request@lists.boost.org wrote:
...
I envisage two threads accessing a function like this concurrently:
template<typename T>
boost::shared_ptr<T>
my_func()
{
    static boost::mutex m;
    boost::mutex::scoped_lock l(m);
static boost::shared_ptr<T> p(new T);
    return p;
}
and my worry is that both threads could attempt to do the static
initialisation of m concurrently.  Is there protection against this?
Is it even possible to protect against this?
The scope of m is actually outside of your function given that it is
static. Thus it will be initialised outside of your function generally
before any other threads get to start up.
This does not sound right to me, so I whipped up a test case... on
HP-UX, given the code:
Sorry, I should have looked at the problem more closely - you're right 
to be suspicious of course. Stroustrup is actually pretty clear on this 
too, "It will be initialized only the first time the thread of 
execution reaches its definition". Whoops - sorry for throwing you off.
Using the Singleton Design Pattern, I have a static mutex in my class 
covering the static instance member. Given their static member nature, 
they get initialised during process startup. Again Stroustrup confirms 
this with, "A variable defined outside any function (that is, global, 
namespace, and *class static variables*) is initialized (constructed) 
before main() is invoked,...".

In case it helps, here's something that I knocked together (and tested) 
using the boost library. The class implements the Singleton design 
pattern safely and is also more robust from an exception handling 
perspective (note: this is the first time I've used boost threads - I'm 
actually using another thread class library...):

*****
#include <stdexcept>
#include 

// Modified Singleton class from Gamma et. al. Returns
// a reference to the instance instead of a pointer
// recognising the use of exceptions. Additionally,
// the instance is guaranteed to be allocated in a
// thread safe manner.

class Singleton
{
   public:

     static Singleton& Instance() throw(std::bad_alloc);

   protected:

     Singleton() throw(std::bad_alloc);

   private:

     static Singleton* mInstanceP;
     static boost::mutex mInstancePMutex;

};

// Implementation

using namespace boost;
using namespace std;

Singleton* Singleton::mInstanceP = 0;
mutex Singleton::mInstancePMutex;

Singleton& Singleton::Instance() throw(bad_alloc)
{
     boost::mutex::scoped_lock theInstancePMutexLock(mInstancePMutex);

     if (mInstanceP == 0)
         mInstanceP = new Singleton();

     return *mInstanceP;
}

Singleton::Singleton() throw(bad_alloc)
{}

int main (int argc, char * const argv[])
{
     try
     {
         Singleton& theSingleton = Singleton::Instance();
             // Guaranteed thread safe.
     }
     catch (const bad_alloc&)
     {}

     return 0;
}
*****

'hope that this is useful.

Cheers,
-C