设计模式_单例模式

单例模式

概念：在写程序的时候，我们希望程序在运行期间有且只有一个实例（具体见应用场景），所以就引出了单例模式，它是指一个类在程序的生命周期中只有一个实例化的对象，并且提供该实例的全局访问方法。

优点：

• 在内存中只有一个对象，节省内存空间；
• 避免频繁的创建销毁对象，可以提高性能；
• 避免对共享资源的多重占用；
• 可以全局访问；

应用场景：

• 需要频繁实例化然后销毁的对象；
• 频繁访问数据库或文件的对象；
• 创建对象耗时过多或者耗费资源过多，但又经常用到的对象；
• 有状态的工具类对象；
• 以及其他要求只有一个对象的场景；

我们可以通过让构造函数私有，防止外界利用new创建此类实例，提供一个共有静态函数，实现访问该实例的方法；

单利模式可以分为懒汉式和饿汉式：

懒汉式：

    第一次用到类的实例的时候才去实例化。

实现Ⅰ

#include <iostream>

using namespace std;
class Singleton{
    private:       //防止外界创建对象
        Singleton(){}
    private:
        static Singleton* p;//可以进行全局访问
    public:
        static Singleton* Initance();//获得本类的全局访问点
        void display(){
            cout<<"Singleton Intitance"<<endl;
        }
};
Singleton* Singleton::p = NULL;
Singleton* Singleton::Initance(){
    if(p == NULL){
        p = new Singleton();
    }
    return p;
}
int main()
{
    Singleton *Temp = Singleton::Initance();
    Temp->display();
    return 0;
}

    仔细分析上面代码就会发现，如果是在单线程方式下，代码是满足安全性的，但是考虑到多线程方式，此代码明显不安全。

实现Ⅱ

#include <iostream>

using namespace std;
class Singleton{
    private:       //防止外界创建对象
        Singleton(){}
    private:
        static Singleton* p;//可以进行全局访问
    public:
        static Singleton* Initance();//获得本类的全局访问点
        void display(){
            cout<<"Singleton Intitance"<<endl;
        }
};
Singleton* Singleton::p = NULL;
Singleton* Singleton::Initance(){
    lock();//加锁
    if(p == NULL){
        p = new Singleton();
    }
    unlock();//解锁
    return p;
}
int main()
{
    Singleton *Temp = Singleton::Initance();
    Temp->display();
    return 0;
}

    再对上面的代码进行分析，上面的代码可以实现多线程下安全，但是只要是调用 Initance（）函数都会先进行锁定，不管之前有没有创建实例，这样会很浪费资源，所以还需要进行优化。

实现Ⅲ

#include <iostream>

using namespace std;
class Singleton{
    private:       //防止外界创建对象
        Singleton(){}
    private:
        static Singleton* p;//可以进行全局访问
    public:
        static Singleton* Initance();//获得本类的全局访问点
        void display(){
            cout<<"Singleton Intitance"<<endl;
        }
};
Singleton* Singleton::p = NULL;
Singleton* Singleton::Initance(){
    if(p == NULL){
        lock();//加锁
        if(p == NULL){
            p = new Singleton();
        }
        unlock();//解锁
    }
    return p;
}
int main()
{
    Singleton *Temp = Singleton::Initance();
    Temp->display();
    return 0;
}

    看到上面的代码你有可能会说，为啥加了锁有还要判断p == NULL，因为如果有两个线程同时进行了p == NULL的判断，虽然接下来会有一个线程先实例化，但是如果不加p == NULL，另一个线程等上一个线程unlock（）后，又会进行实例化，所以还要判断一下p == NULL。

饿汉式：

    在单例类定义的时候实现实例化。

#include <iostream>

using namespace std;
class Singleton{
    private:       //防止外界创建对象
        Singleton(){}
    private:
        static Singleton* p;//可以进行全局访问
    public:
        static Singleton* Initance();//获得本类的全局访问点
        void display(){
            cout<<"Singleton Intitance"<<endl;
        }
};
Singleton* Singleton::p = new Singleton;
Singleton* Singleton::Initance(){
    return p;
}
int main()
{
    Singleton *Temp = Singleton::Initance();
    Temp->display();
    return 0;
}

Reference :

• https://www.cnblogs.com/cxjchen/p/3148582.html
• https://www.cnblogs.com/qiaoconglovelife/p/5851163.html
  
• https://www.cnblogs.com/qianqiannian/p/6541884.html