C++之单例模式

一、概念

确保一个类只有一个实体对象，必须是自行创建的实例。并且能向整个系统提供实例。转换成实现的方法就是，（1）构造函数私有，避免了外部实例化。（2）该类包含一个自己的静态对象。（3）提供一个静态的公有函数供外部使用。

• 二、懒汉式单例

概念:在使用时候才会去创建对象，不然懒得创建。所以称为懒汉式。这种模式在多线程时候可能存在线程安全，因为可能多个线程同时访问创建。好处就是没有调用就不占用内存。

1、懒汉式非线程安全模式

class singleSampleIdler {//懒汉单例(非安全)

private:

    singleSampleIdler() { cout << "懒汉单例构造(非线程安全)" << endl; };//私有的构造函数

    singleSampleIdler(singleSampleIdler&) = delete;//禁止拷贝构造，目的是为了限制实例生成

    singleSampleIdler& operator=(const singleSampleIdler&) = delete;//禁止赋值。目的同上

    static singleSampleIdler* Instance;

public:

    static singleSampleIdler* GetInstance()

    {

        if (Instance == NULL)

        {

            Instance = new singleSampleIdler();

        }

        return Instance;

    };

public:

    void coutSingle() {

        cout << "这是一个懒汉模式非线程安全调用" << endl;

    };

};

//类外初始化静态数据

singleSampleIdler* singleSampleIdler::Instance = nullptr;

注意：当两个线程同时进去GetInstance()这个函数，Instance就会发生两次构造。线程与内存都不安全，因为只有new,没有delete.

2、懒汉式线程安全模式

class singleSampleIdler {//懒汉单例(安全)

private:

    singleSampleIdler() { cout << "懒汉单例构造(线程安全)" << endl; };//私有的构造函数

    singleSampleIdler(singleSampleIdler&) = delete;//禁止拷贝构造，目的是为了限制实例生成

    singleSampleIdler& operator=(const singleSampleIdler&) = delete;//禁止赋值。目的同上

    static singleSampleIdler* Instance;

    static std::mutex mutex;

public:

    static singleSampleIdler* GetInstance()

    {

        if (Instance == NULL)//第一次判断

        {

            std::lock_guard<std::mutex> guard(mutex); //表示上锁的函数

            if(Instance == NULL)//第二次判断

                Instance = new singleSampleIdler();

        }

        return Instance;

    };

public:

    void coutSingle() {

        cout << "这是一个懒汉模式线程安全调用" << endl;

    };

};

//类外初始化静态数据

singleSampleIdler* singleSampleIdler::Instance = nullptr;

std::mutex singleSampleIdler::mutex;

注意：为啥要加两次判断，是为了不需要每次都访问锁，增加效率。但是同样存在内存安全。

• 三、饿汉式单例

饿汉式是指在用户调用前就已经创建好实例。因为使用的是static静态定义，根据C++静态初始化是安全的定（C++0x版本后）。所以该模式是线程安全的。

例子:

/*饿汉*/

class singleSampleHungry {//饿汉单例

private:

    singleSampleHungry() { cout << "饿汉单例构造" << endl; };//私有的构造函数

    singleSampleHungry(singleSampleHungry&) = delete;//禁止拷贝构造，目的是为了限制实例生成

    singleSampleHungry& operator=(const singleSampleHungry&) = delete;//禁止赋值。目的同上

    static singleSampleHungry* Instance;

public:

    static singleSampleHungry* GetInstance()

    {

        return Instance;

    }

public:

    void coutSingle() {

        cout << "这是一个饿汉模式调用" << endl;

    };

};

singleSampleHungry* singleSampleHungry::Instance = new singleSampleHungry();

int main()

{

   

    singleSampleHungry::GetInstance()->coutSingle();

    getchar();

}

• 四、智能指针懒汉模式

基于上面的几种都不能做到内存安全，也就是不能做到内存回收。所以利用智能指针内存回收释放的特性实现单例模式。

例子:

class singleSample {//智能单例

private:

    singleSample() { cout << "智能单例构造" << endl; };//私有的构造函数

    ~singleSample() { cout << "智能单例析构" << endl; };//私有的析构函数

    //singleSample(singleSample&) = delete;//禁止拷贝构造，目的是为了限制实例生成

    //singleSample& operator=(const singleSample&) = delete;//禁止赋值。目的同上

    static shared_ptr<singleSample> Instance;

    static mutex mutex;

public:

    static void dele(singleSample *in) {

        cout << "智能删除函数" << endl;

        delete in;

    };

    static singleSample* GetInstance()

    {

        if (Instance == NULL) //第一次判断

        {

            std::lock_guard<std::mutex> guard(mutex); //表示上锁的函数 

            if (Instance == NULL)  //第二次判断

            {

               Instance = std::shared_ptr<singleSample>(new singleSample(), singleSample::dele);

            }

        }

        return Instance.get();

    

    }

public:

    void coutSingle() {

        cout << "这是一个智能模式调用" << endl;

    };

};

shared_ptr<singleSample> singleSample::Instance=nullptr;

mutex singleSample::mutex;

int main()

{

   

    singleSample::GetInstance() ->coutSingle();

    getchar();

}