单例模式

单件模式（SingletonPattern）：确保一个类只有一个实例，并提供一个全局访问点。和全局变量一样方便，又没有全局变量的缺点，即不需要从一开始就创建对象，而是在需要时才创建它

 

单例模式中分为饿汉模式和懒汉模式

 

由于要进行线程同步，所以在访问量比较大，或者可能访问的线程比较多时，采用饿汉实现，可以实现更好的性能。这是以空间换时间。

在访问量较小时，采用懒汉实现。这是以时间换空间。

 

懒汉模式：就是尽可能晚的创建这个对象的实例，即在单例类第一次被引用时将自己初始化；其实C++里很多地方都是类似这样的思想，比如晚绑定，写时拷贝技术等，就是尽量使资源的利用最大化，不要让空闲的人还占着有限的资源。

 

 

#include<iostream>

#include<string>

#include<vector>

using namespace std;

 

class Singelton

{

private:

Singelton(){}

static Singelton* singel;

 

public:

static Singelton* GetInstance()

{

if(singel == NULL)

{

singel = new Singelton();

}

return singel;

}

};

 

Singelton* Singelton::singel = NULL;//静态变量外部初始化

 

int main()

{

Singelton* s1 = Singelton::GetInstance();

Singelton* s2 = Singelton::GetInstance();

if(s1 == s2)

cout<<"ok"<<endl;

else

cout<<"NO"<<endl;

return 0;

}

 

饿汉模式：即在最开始的时候，静态对象就已经创建完成；

设计方法是类中包含一个静态成员指针，该指针指向该类的一个对象，提供一个公有的静态成员方法，返回该对象指针；为了使得对象唯一，还需要将构造函数设为私有，代码如下：

#include<iostream>

#include<string>

#include<vector>

using namespace std;

 

class Singelton

{

private:

Singelton(){}

static Singelton* singel;

 

public:

static Singelton* GetInstance()

{

return singel;

}

};

 

Singelton* Singelton::singel = new Singelton;//与单例懒汉模式模式不同

 

int main()

{

Singelton* s1 = Singelton::GetInstance();

Singelton* s2 = Singelton::GetInstance();

if(s1 == s2)

cout<<"ok"<<endl;

else

cout<<"NO"<<endl;

return 0;

}

 

单例的饿汉实现是线程安全的，因为对象在使用前就已经创建出来了。

 

 

单例懒汉线程安全实现：

采用加锁机制：

#include<iostream>

using namespace std;

class Singleton

{

private:

    Singleton(){}

    static Singleton* m_Instance;

public:

    static pthread_mutex_t mutex;

    static Singleton* initance();

};

 

pthread_mutex_t Singleton::mutex = PTHREAD_MUTEX_INITIALIZER;

Singleton* Singleton::m_Instance = NULL;

Singleton* Singleton::initance()

{

    if (NULL == m_Instance)

    {

        pthread_mutex_lock(&mutex);

        if (NULL == m_Instance)

            m_Instance = new Singleton();

        pthread_mutex_unlock(&mutex);

    }

    return m_Instance;

};