C++实现懒汉式单例模式

单例模式无论在生活中还是在工程中都有很广泛的应用，在C++项目中，很多时候我们只希望整个工程中某个类仅有一个实体对象，设计这种类的时候就需要使用单例模式来设计。下面是实现的一个懒汉式单例模式的代码：

#include <iostream>#include <cstdio>using std::cout;using std::endl;class Singleton {    private :        static Singleton* p_obj;        Singleton(void){        }    public :        static Singleton* GetInstance(void){            if(p_obj == NULL){                p_obj = new Singleton();                cout << "New Singleton();" << endl;                return p_obj;            }        }        ~Singleton(void){            if(p_obj!=NULL){                delete p_obj;                p_obj = NULL;                cout << "~Singleton" << endl;            }        }};Singleton* Singleton::p_obj = NULL;void run(void){    Singleton* s1 = Singleton::GetInstance();    Singleton* s2 = Singleton::GetInstance();    cout << "ADDR s1:" << s1 << endl;    cout << "ADDR s2:" << s2 << endl;     }int main(){    run();        cout << "Press enter to continue..." << endl;    getchar();    return 0;}

在设计类的时候，声明了一个static Singleton类型的指针在类的私有成员区，需要注意的是，这个指针的内存单元并不会在对象中开辟，需要程序员自己在全局定义一个Singleton指针，如果不是单例模式的类，这种static类型的成员是每一个对象共享的，即所有的对象都可以访问在全局数据区的这一段static内存。

在类私有成员区还定义了构造函数，显然地，这样设计时不想让程序员可以直接创建Singleton对象，而是需要创建Singleton指针使用GetInstance方法去创建一个对象。这里需要我们知道C++编译器的一个特性：当程序员在设计类的时候，没有显示地声明构造函数，编译器会默认提供一个空的构造函数。这种懒汉式单例模式的实现，就是利用了C++的这一特性，将构造函数声明在类私有成员区，如果程序员在外部创建Singleton对象，编译器将报错：Singleton成员函数时私有的，不可访问。

如果想要调用Singleton类中的GetInstance函数创建对象，首先会判断一下p_obj指针是不是为空，即是不是还没有开辟过这个对象，如果确实目前还没有开辟过这个对象，那么使用new关键字在堆空间中开辟一段Sngleton大小的内存给申请者，而如果程序中早已存在Singleotn对象，则把已经存在的Singleton对象在堆空间中的地址返回给申请者。

其实这段程序是有漏洞的，在类中实现的析构函数并不会释放堆内存，因为它根本就没有被调用。这就造成了堆内存泄露的灾难。不能够在析构中释放内存，而是需要调用者手动地释放堆内存。改进这个漏洞后的代码如下：

#include <iostream>#include <cstdio>using std::cout;using std::endl;class Singleton {    private :        static Singleton* p_obj;        Singleton(){        }    public :        static Singleton* GetInstance(){            if(p_obj == NULL){                p_obj = new Singleton();                cout << "New Singleton();" << endl;                return p_obj;            }        }};Singleton* Singleton::p_obj = NULL;void run(){    Singleton* s1 = Singleton::GetInstance();    Singleton* s2 = Singleton::GetInstance();    cout << "ADDR s1:" << s1 << endl;    cout << "ADDR s2:" << s2 << endl;        delete s1;}int main(){    run();        cout << "Press enter to continue..." << endl;    getchar();    return 0;}

显然，改进了的代码在单线程系统中不会再造成堆内存泄露。为什么要强调一下是单线程的系统中呢？因为它在多线程的系统中还是可能出问题，想象一下，同时两个线程运行到了if(p_obj == NULL),这时候会怎样？显然，会在堆内存中申请两个Singleton大小的内存段。然而我们只释放了一个，想象中他们是同一段，这就造成了泄露了一段Singleton大小的内存。改进这个漏洞的方法是在if(NULL != p_obj)前后加锁，改进如下：

#include <iostream>#include <cstdio>using std::cout;using std::endl;class Singleton {    private :        static Singleton* p_obj;        Singleton(){                    }    public :        static Singleton* GetInstance(){            lock();            if(p_obj == NULL){                p_obj = new Singleton();                cout << "New Singleton();" << endl;                return p_obj;            }            unlock();        }};Singleton* Singleton::p_obj = NULL;void run(){    Singleton* s1 = Singleton::GetInstance();    Singleton* s2 = Singleton::GetInstance();    cout << "ADDR P1:" << s1 << endl;    cout << "ADDR P2:" << s2 << endl;        delete s1;}int main(){    run();        cout << "Press enter to continue..." << endl;    getchar();    return 0;}

然而这样做的在线程很多的时候会影响代码的效率，试想当多个线程都想要申请这么这段内存的时候，都被调度器阻塞，堆在一起等待，这是一件多可怕的事情。为了提高代码的运行效率，可以使用双重判断加锁，改进如下：

static Singleton* GetInstance(){    if(p_obj == NULL){        lock();        if(p_obj == NULL){            p_obj = new Singleton();            cout << "New Singleton();" << endl;            return p_obj;        }        unlock();    }}

多判断一次，减少多线程共同排队到这个位置的可能性。