多线程安全的单件模式，模板基类的单件实现

#include "stdio.h"
#include "Lock.h"
///======================================
/// 线程安全的单件模式
/// 历史的尘埃
/// 2009.3.25
///======================================
class Singleton
{
private:
Singleton()
{

};
static Lock* m_Lock;
static Singleton* m_Singleton;
public:
static Singleton* GetInstance();
~Singleton()
{
if( m_Lock != NULL )
{
delete m_Lock;
m_Lock = NULL;
}
}
void Do()
{
printf( "ok" );
}
};

Singleton* Singleton::m_Singleton = NULL;
Lock* Singleton::m_Lock = new Lock();

Singleton* Singleton::GetInstance()
{
//首先检查，如果未初始化，则进入临界区。
if( m_Singleton == NULL )
{
AutoLock lock( m_Lock );
//再次检查，防止有其他线程在临界区的等待时间中创建了对象
if( m_Singleton == NULL )
{
m_Singleton = new Singleton();
}
}
return m_Singleton;
}

///======================================
/// 实现单件的模板
/// 此基类在继承时主要注意要声明此基类的该类实现为其友元类
/// 历史的尘埃
/// 2009.3.25
///======================================
template<class T>
class Single
{
protected:
Single()
{

};
static Lock* m_Lock;
static T* m_T;
public:
static T* GetInstance()
{
if( m_T == NULL )
{
AutoLock lock( m_Lock );
if( m_T == NULL )
{
m_T = new T();
}
}
return m_T;
}
~Single()
{

}
};

template<class T>
Lock* Single<T>::m_Lock = new Lock();

template<class T>
T* Single<T>::m_T = NULL;

class SingleImp
:public Single<SingleImp>
{
private:
SingleImp()
{

}
friend class Single<SingleImp>;

public:
void Do()
{
printf( "SingleImp" );
}
};

int main()
{
Singleton* pS = Singleton::GetInstance();
pS->Do();
SingleImp* pSI = SingleImp::GetInstance();
pSI->Do();
return 0;
}