C++开发之单例模式的实现

前言：主要是介绍饿汉模式和懒汉模式的实现

---

1.单例模式

• 所谓单例,就是整个程序有且仅有一个实例。该类负责创建自己的对象,同时确保只有一个对象被创建。
• 单例模式的作用主要是为了避免创建多个实例，目的是为了产生全局唯一的一个示例。此处的全局表示的是进程内部，多个进程肯定有自己多个实例，因为操作系统按照进程来划分内存。
• • 单例模式分为饿汉模式和懒汉模式，其中饿汉模式用的比较多。

2.饿汉模式

此处使用堆创建的方式演示， 饿汉式属于线程安全。

#include <iostream>
//单例模式 饿汉
using namespace std;

class Student{
    //1构造私有化
    Student() = default;
    //2该类的一个指针． 静态的成员全局唯一．
    static Student *instance;
public:
    //3返回实例
    static Student *getInstance(){
        return instance;
    }
};

//创建实例
Student *Student::instance = new Student();
int main() {
    Student *s1 = Student::getInstance();
    Student *s2 = Student::getInstance();
    cout<<s1<<endl;
    cout<<s2<<endl;
    return 0;
}

3.普通懒汉模式

懒汉式的意思是： 只有到来获取对象的时候才急忙的去创建对象

#include <iostream>
//单例模式 懒汉
using namespace std;

class Student{
    //1构造私有化
    Student() = default;
    //2该类的一个指针． 静态的成员全局唯一．
    static Student *instance;
public:
    //3返回实例
    static Student *getInstance(){
        if(instance == nullptr){
            instance = new Student();
        }
        return instance;
    }
};

//创建实例
Student *Student::instance = nullptr;
int main() {
    Student *s1 = Student::getInstance();
    Student *s2 = Student::getInstance();
    cout<<s1<<endl;
    cout<<s2<<endl;
    return 0;
}

4.懒汉模式引发的多线程问题

在多个线程同时并发获取对象的情况下，还是有可能出现创建多实例的情况。

#include<iostream>
#include <mutex>
using namespace std;

class Student {
private:
    static mutex m;
    Student()=default;
    static Student * instance;
public:
    static Student * getInstance() {
        //每次获取实例都要检查锁，效率很低。
        m.lock();
        if (instance == nullptr){
            instance = new Student();
        }
        m.unlock();
        return instance;
    }
};

//静态成员需要在外面初始化。
Student * Student::instance = nullptr;

int main(){
    Student *s1 = Student::getInstance();
    Student *s2 = Student::getInstance();
    cout<<s1<<endl;
    cout<<s2<<endl;
    return 0;
}

5.懒汉模式的双锁检查

对获取实例的函数进行优化，执行双锁检查。

#include <iostream>
#include <mutex>
//单例模式 懒汉
using namespace std;

class Student{
    static mutex m;
    //1构造私有化
    Student() = default;
    //2该类的一个指针． 静态的成员全局唯一．
    static Student *instance;
public:
    //3返回实例
    static Student *getInstance(){
        if(instance == nullptr){
            m.lock();
            if (instance == nullptr){
                instance = new Student();
            }
            m.unlock();
        }
        return instance;
    }
};

//创建实例
Student *Student::instance = nullptr;
int main() {
    Student *s1 = Student::getInstance();
    Student *s2 = Student::getInstance();
    cout<<s1<<endl;
    cout<<s2<<endl;
    return 0;
}

---

结束！！！