单例模式

全局静态变量实现饿汉式单例模式

饿汉式实现方式是线程安全的。

黑

#include using namespace std; 
/* 饿汉式单例模式 */ 
class SingleObject{ 
    private: 
        static SingleObject instance; 
        SingleObject(){
            std::cout << "Singleton instance created." << std::endl;
        }
    public: 
        static SingleObject get_instance(){ 
        return instance; //非静态成员是不存在，是无法返回实例的 
        } 
        void show_message(); 
};
SingleObject SingleObject::instance;
int main(){ 
    cout << "---------主线程开始---------" << endl；
    SingleObject::get_instance().show_message(); 
    cout << "---------主线程结束---------" << endl; 
    return 0; 
} 

void SingleObject::show_message(){ 
    cout << "完成了单例模式" << endl; }

局部静态变量实现懒汉单例模式

这种也是线程安全的单例模式实现，实现原则是局部静态变量实现，返回引用

//更简单的线程安全初始化 
#include using namespace std; 
class SingleObject{ 
    private: 
        SingleObject(){
            std::cout << "Singleton instance created." << std::endl;
        }
    public: 
        //这里返回类型为引用可以避免对对象的复制，以及拷贝构造函数和析构函数的调用，开销小。
        static SingleObject& get_instance(){ 
            static SingleObject instance;//局部静态变量实现单例模式
            return instance; //非静态成员是不存在，是无法返回实例的 
        } 
        void show_message(); 
};

int main(){ 
    cout << "---------主线程开始---------" << endl; 
    SingleObject& my_instance = SingleObject::get_instance()；
    my_instance.show_message(); 
    cout << "---------主线程结束---------" << endl; return 0;
} 

void SingleObject::show_message(){
     cout << "完成了单例模式" << endl; 
} 

指针实现懒汉单例模式

此方式未加互斥锁，是不线程安全的

#include <iostream>
using namespace std;
/* 饿汉式单例模式 */
class SingleObject
{
private:
    static SingleObject *instance; // 通过指针延迟初始化
    SingleObject() { std::cout << "Singleton instance created." << std::endl; }

public:
    static SingleObject* get_instance()
    {
        if (instance == nullptr) //多线程在执行判断条件时，可能同时发现都是nullptr，同时实例化多个对象。线程不安全
            instance = new SingleObject();
        return instance; //实例的指针
    }
    void show_message();
};

SingleObject* SingleObject::instance = nullptr;
int main()
{
    cout << "---------主线程开始---------" << endl;
    SingleObject* instance = SingleObject::get_instance();
    (*instance).show_message();
    cout << "---------主线程结束---------" << endl;
    return 0;
}
void SingleObject::show_message()
{
    cout << "完成了单例模式" << endl;
}

指针加互斥量实现懒汉单例模式

这种互斥量加锁实现方式是线程安全的

#include <iostream>
#include <mutex>

/* 饿汉式单例模式 */
class SingleObject
{
private:
    static SingleObject *instance; // 通过指针延迟初始化
    SingleObject() { std::cout << "Singleton instance created." << std::endl; }
    static std::mutex mtx;//新建一个互斥量，预备实现线程安全
public:
    static SingleObject* get_instance()
    {
        if (instance== nullptr){
            std::lock_guard<std::mutex> lock(mtx);
            if(instance == nullptr)
            instance = new SingleObject();
        }
        return instance; //实例的指针
    }
    void show_message();
};
SingleObject* SingleObject::instance = nullptr; //指针初始化
std::mutex SingleObject::mtx;//初始化 互斥锁
int main()
{
    std::cout << "---------主线程开始---------" << std::endl;
    SingleObject* instance = SingleObject::get_instance();
    (*instance).show_message();//或者使用instance->show_message()
    std::cout << "---------主线程结束---------" << std::endl;
    return 0;
}
void SingleObject::show_message()
{
    std::cout << "完成了单例模式" << std::endl;
}