class MyClass {
public:
  MyClass();
  static TMutex mutex;
};
...

TMutex MyClass::mutex;

А>class MyClass {
А>public:
А>  MyClass();
А>  static TMutex mutex;
А>};
А>...

А>TMutex MyClass::mutex;
А>

TMutex& global_mutex() {
    static TMutex t;
    return t;
}

...

// и в программе везде юзаешь:

global_mutex().TryLock();

template<typename T, T* (*unique_func)(bool) >
struct fstatic_body 
{
    static T* obj;
    static mutex mt;

    // вызываем этот метод в теле многопоточной программы
    static T* get_mt() {
        if(!obj) {
            guard lock(mt);
            if(!obj)
                obj = new T();
        }

        return obj;
    }

    // вызываем этот метод в теле конструкторов глобальных объектов
    static T* get() {
        if(!obj)
            obj = new T();

        return obj;
    }

    ~fstatic_body() { if(obj) delete obj; } // грохаем статический объект в деструкторе экземпляра :)
};

template<typename T, T* (*unique_func)(bool)> 
T* fstatic_body<T, unique_func>::obj = NULL;

template<typename T, T* (*unique_func)(bool)> 
mutex fstatic_body<T, unique_func>::mt;

struct SomeType {};

SomeType* get_some_obj(bool from_ctor = false) {
    static fstatic_body<SomeType, get_some_obj> st;
    if(from_ctor)
        return st.get();     // :)
    else
        return st.get_mt();
}

// можно макросом подсобить
#define DEF_SGTON(type, name) \
// тут переписать ф-ию get_some_obj с подстановкой type и name

/// Static mutex.
template<class T>
class static_mutex
{
public:
    /// Scoped lock.
    class scoped_lock: boost::noncopyable
    {
    public:
        /// Constructor. Lock.
        scoped_lock() { while(InterlockedExchange(&X, 1)) Sleep(1); }
        /// Destructor. Unlock.
        ~scoped_lock() { InterlockedExchange(&X, 0); }    
    };
private:
    static volatile LONG X;
};

template<class T>
volatile LONG static_mutex<T>::X = 0;

class MyClass {
public:
  MyClass();
};

    {
        static_mutex<MyClass>::scoped_lock Lock;
        ...
    }