c++的设计模式之一(单例模式)

其实我们首先应该来考虑一下c++为什么会有这么多的设计模式呢？？？？？？？

既然有，就说明它们有着举足轻重的作用！！！！！！！！

设计模式的作用：记得有人这样说过：设计模式模式之于面向对象系统的设计和开发的作用就有如数据结构之于面向过程开发的作用一般，可见它的作用是多么的大，

有以下作用（作用为摘抄）：

(1)重用设计，重用设计比重用代码更有意义，它会自动带来代码的重用。

(2)为设计提供共用的词汇，每个模式名就是一个设计词汇，其概念使得程序员间的交流更加方便。

(3)在开发文档中采用模式词汇可以让其他人更容易理解你的想法，理解为什么要这样做。编写开发文档更方便。

(4)应用设计模式可以让重构系统变得容易，可确保开发正确的代码，并降低在设计或实现中出现错误的可能性，还可以重写其他应用程序提供很好的系统框架。

(5)正确使用设计模式，可以节省大量的时间等等。

哎，菜鸟一枚，不能很清楚叫上C++23种设计模式的名字，更别说了解了，不过慢慢渗透吧，先慢慢了解，觉得这应该是一个深入骨髓的东西，而我还在皮毛上徘徊，，最近在看这方面的书，看了几种设计模式，自己想巩固巩固：

/单例模式//

singleton模式应该是这些模式里面最简单，最容易实现的模式了，也应该是面试官最容易问到的模式了吧。

所谓单例模式，就是一个类只能产生一个对象，这应该挺重要的，比如打印机机的对象，一次只能有一个正在工作，一个系统只能有一个窗口管理器，对话框，日志对象等等。

我们先来看一下第一种：

线程安全的Singleton（不属于懒加载）

class SingleTon
{
public:
    static SingleTon* getInstance()
    {
        return &singleTon;
    }
private:
    SingleTon(){}//构造函数设为私有保证对象不能够随便实例化
    static SingleTon singleTon;//此对象为全局，存在于数据段，程序运行起来就已经初始化了，是线程安全的，只初始化一次，不属于懒加载
};
SingleTon SingleTon::singleTon;

第二种：

线程安全的Singleton（不属于懒加载）

class SingleTon
{
public:
    static SingleTon* getInstance()
    {
        static SingleTon singleTon; //初始化在调用getinstance函数时，是线程安全的
        return &singleTon;
    }
private:
    SingleTon(){}
};
int main()
{
	return 0;
}

class SingleTon
{
public:
    static SingleTon* getInstance()
    {
        // gcc 4.6
        /*   static int count=0;
        static局部变量只初始化一次
        
        if(!flag)
            lock();
            if(!flag)
                init
                flag=true;
            unlock();
        static局部变量的初始化是由编译器保证
        它的线程安全的******************
        */
        static SingleTon singleTon; 
        return &singleTon;
    }
private:
    SingleTon(){}
};

第三种：

class SingleTon
{
public:
    //getInstance这个函数是不是线程安全的函数？？？
    //getInstance这个函数是不是可重入函数？？？
    static SingleTon* getInstance()
    {
       
        if(mpSingleTon == NULL)
        {
            mpSingleTon = new SingleTon();
        }
        return mpSingleTon;
    }
private:
    SingleTon(){}
    static SingleTon *mpSingleTon;
};
SingleTon *SingleTon::mpSingleTon=NULL;

那么这个版本的单例模式是不是线程安全的呢，也就是说getlnstance这个函数是不是可重入函数，如果是，那么它就是线程安全的，如果不是，那么它也不是线程安全的。

mpSingleTon = new SingleTon();//我们就来看一下这一句都做了些什么：

new我们知道，会分配内存，同时调用构造函数构造对象。最后赋值，我想的是在这期间会有不同的线程来访问此此句，当一个进程对象还没创建完成时，另一个对象也进来创造了，所以第三种只适合在单线程下运行。如果要在多线程下使用，就得加锁。

class SingleTon
{
public:
    //getInstance这个函数是不是线程安全的函数？？？
    //getInstance这个函数是不是可重入函数？？？
    static SingleTon* getInstance()
    {
        pthread_mutex_lock(&mutex);
        if(mpSingleTon == NULL)
        {
            mpSingleTon = new SingleTon();
        }
        pthread_mutex_unlock(&mutex);
        return mpSingleTon;
    }
private:
    SingleTon(){}
    ~SingleTon(){pthread_mutex_destroy(&mutex, NULL);}
    static pthread_mutex_t mutex;
    static SingleTon *mpSingleTon;
};
pthread_mutex_t SingleTon::mutex = PTHREAD_MUTEX_INITIALIZER;
SingleTon *SingleTon::mpSingleTon=NULL;

这样写的话，当然是线程安全的了，但是有一点不好，感觉这锁加的很重，不管是不是空，先加锁，感觉非常耗时，我们应该有所改进一下加锁的位置

class CMutex//锁类
{
public:
    CMutex()
    {
        pthread_mutex_init(&mutex, NULL);
    }
    ~CMutex()
    {
        pthread_mutex_destroy(&mutex);
    }
    void lock()
    {
        pthread_mutex_lock(&mutex);
    }
    void unlock()
    {
        pthread_mutex_unlock(&mutex);
    }
private:
    pthread_mutex_t mutex;
};

class SingleTon
{
public:
    static SingleTon* getInstance()
    {
        if(mpSingleTon == NULL)
        {
            mutex.lock();   // 双重锁机制
            if(mpSingleTon == NULL)
                mpSingleTon = new SingleTon();
            mutex.unlock();
        }
        return mpSingleTon;
    }
private:
    SingleTon(){}
    ~SingleTon(){}
    static CMutex mutex;
    static volatile SingleTon *mpSingleTon;
};
CMutex SingleTon::mutex;
SingleTon *SingleTon::mpSingleTon=NULL;

这样的双重锁机制只有当mpSingleton为NULL时才会加锁创建唯一的对象。在别的线程试图创建对象时加锁。

好啦，到此为止，单例模式就说完啦，再巩固巩固喽。