C++单例模式与线程安全

C++单例模式

单例模式的主要作用是去除全局变量，这个意义在设计模式或者相关的资料中都有比较详细的介绍。

一、 单例常见实现方式

单例的实现方式比较常见的可以分为两个大类：类静态成员指针，函数静态变量。其中《设计模式》书中主要以类静态成员指针进行了讲解，而在《More effective c++》书中介绍了一种更高效的基于函数静态变量的实现方式，下面简单的对它们进行一下显示和总结。

1.1 类静态成员指针实现示例

为了便于展示，将所有的实现都放到了头文件中，代码如下：

1. 懒惰初始化实现

class CMemberSingleton

{

public:

~CMemberSingleton(void){}

staticCMemberSingleton* GetInstance();

private:

CMemberSingleton(void){}

staticCMemberSingleton *m_pInstance;

};

CMemberSingleton*CMemberSingleton::m_pInstance = NULL;

CMemberSingleton* CMemberSingleton::GetInstance()

{

if(NULL != m_pInstance)

{

m_pInstance= new CMemberSingleton;

}

returnm_pInstance;

}

2. 普通实现

class CMemberSingleton

{

public:

~CMemberSingleton(void){}

staticCMemberSingleton* GetInstance();

private:

CMemberSingleton(void){}

staticCMemberSingleton *m_pInstance;

};

CMemberSingleton*CMemberSingleton::m_pInstance = new CMemberSingleton;

CMemberSingleton*CMemberSingleton::GetInstance()

{

returnm_pInstance;

}

3. 总结

基于静态成员变量的单例实现，无法实现对于单例的销毁工作，当然直接提供一个DestoryInstance这种函数给使用者调用是可以，但是调用的时机却是很不好把握的。

1.2 函数静态变量实现示例

基于函数静态变量来实现单例可以解决1.1中基于类静态成员变量中实例销毁问题。示例代码如下：

class CMemberSingleton

{

friendCMemberSingleton& GetInstance();

public:

~CMemberSingleton(void){}

private:

CMemberSingleton(void){}

};

CMemberSingleton& GetInstance()

{

staticCMemberSingleton instance;

returninstance;

}

当然根据个人喜好，你也可以将GetInstance写成类的静态函数，实现效果是一致的。

1.3 自动销毁的基于类静态成员单例实现

如果说你确实非常喜欢基于静态成员来实现单例，或者某些因素强制你必须使用静态成员，我们也还是可能借助下面的方法来实现自动销毁工作。

class CMemberSingleton

{

public:

~CMemberSingleton(void){}

staticCMemberSingleton* GetInstance();

private:

CMemberSingleton(void){}

staticCMemberSingleton *m_pInstance;

classCGarbo

{

public:

~CGarbo()

{

if(NULL != CMemberSingleton::m_pInstance)

{

deleteCMemberSingleton::m_pInstance;

}

}

};

staticCGarbo m_garbo;

};

CMemberSingleton::CGarboCMemberSingleton::m_garbo = CMemberSingleton::CGarbo();

CMemberSingleton*CMemberSingleton::m_pInstance = NULL;

CMemberSingleton*CMemberSingleton::GetInstance()

{

returnm_pInstance;

}

二、 单例线程安全性

关于单例的实现方式上面已经进行了简单的介绍，如果我们不编写多线程代码，这一段的讨论你可以忽略。

单例是线程安全的吗（注意我们只讨论单例的获取，也就是常见的GetInstance，至于单例对应类的成员函数线程安全性，此处不作讨论）？回答是否定的！单例不是线程安全的，如果你实现的单例被多个线程调用，那么你就要注意了，很可能在某个时间出现异常（通常是程序启动的时候了！）。下面用一个例子展示一下，示例代码如下：

1. 单例代码

classCMemberSingleton

{

public:

~CMemberSingleton(void);

static CMemberSingleton* GetInstance();

private:

CMemberSingleton(void);

static CMemberSingleton *m_pInstance;

};

CMemberSingleton*CMemberSingleton::m_pInstance = NULL;

CMemberSingleton::CMemberSingleton(void)

{

cout<<"construct CMemberSingleton"<<endl;

}

CMemberSingleton::~CMemberSingleton(void)

{

cout<<"destoryCMemberSingleton"<<endl;

}

CMemberSingleton*CMemberSingleton::GetInstance()

{

if (NULL == m_pInstance)

{

m_pInstance = newCMemberSingleton;

}

return m_pInstance;

}

2. 主函数代码

void* thread_func(void *param)

{

CMemberSingleton::GetInstance();

return NULL;

}

int main(char **argv, int argc)

{

int i = 0;

pthread_t pids[100] ={0};

for (i = 0; i < 3;++i)

{

pthread_create(&pids[i],NULL, thread_func, NULL);

}

for (i = 0; NULL !=pids[i].p; ++i)

{

void *p = NULL;

pthread_join(pids[i],&p);

}

system("pause");

return 0;

}

3. 某次的执行结果

图1


执行结果可以明显看出，我们需要的是单例，却实际构造了三次，所以单例不一定是线程安全的。

4. 最简单的解决办法

关于解决单例线程安全的办法也许有很多，但是很多情况你都不可避免的要通过线程同步的方式来实现，下面介绍一种不需要线程同步的安全的单例实现。代码如下：

class CMemberSingleton

{

public:

~CMemberSingleton(void);

static CMemberSingleton*GetInstance();

private:

CMemberSingleton(void);

static CMemberSingleton*m_pInstance;

};

CMemberSingleton* CMemberSingleton::m_pInstance = newCMemberSingleton;

CMemberSingleton::CMemberSingleton(void)

{

cout<<"constructCMemberSingleton"<<endl;

}

CMemberSingleton::~CMemberSingleton(void)

{

cout<<"destoryCMemberSingleton"<<endl;

}

CMemberSingleton* CMemberSingleton::GetInstance()

{

return m_pInstance;

}

关于运行的结果就不再上图了，原理大家也应该明白，类的静态成员会在main函数运行之间就进行初始化的操作，如果我们不把它初始化为NULL,而是直接初始化一个对象给它，那么在有线程访问时，它已经初始化完成了，所以不会有线程同步的问题了。

虽然这个办法很好的解决了多线程安全问题，但是关于单例对象的销毁工作，就需要额外的实现了，你喜欢提供DestoryInstance这种函数，还是采用1.3中的“垃圾工”来帮你完成销毁任务呢？