4.17-c++多线程学习-call_once与其使用场景（单例模式场景）

单例模式

单例设计模式是一种常见的设计模式，用于确保某个类只能创建一个实例。由于单例实例是全局唯一的，因此在多线程环境中使用单例模式时，需要考虑线程安全的问题。

Call_once:

C++11 标准库中的一个多线程同步工具，用于保证某个函数在多线程环境下只被调用一次。 可以被用于初始化单例模式中的唯一实例或者其他需要被全局初始化的对象。

饿汉模式&懒汉模式

懒汉模式和饿汉模式都是单例模式的实现方式。
懒汉模式是在第一次使用单例对象时才进行实例化，之后每次调用都返回第一次创建的实例。在多线程环境下需要考虑线程安全性。
饿汉模式是在程序启动时就进行实例化，之后每次调用都返回同一个实例。因为实例在程序启动时就已经创建，所以不存在线程安全性的问题。
饿汉模式的优点是实现简单，不存在线程安全问题；缺点是不管是否使用对象都会进行实例化，可能会浪费一定的内存空间。懒汉模式的优点是节省内存空间；缺点是在多线程环境下需要考虑线程安全问题。

饿汉模式&懒汉模式简单应用

//懒汉模式
#include <iostream>
#include <thread>
#include <mutex>
#include<string>
using namespace std;


class Log
{
public:
    Log() {};
    Log(const Log& log) = delete;
    Log& operator=(const Log& log) = delete;

    static Log& GetInstance()
    {
        static Log* log = nullptr;//懒汉模式，初始化为 nullptr
        if (!log)//如果单例对象为空，那么进行初始化
        {
            log = new Log;// 初始化单例对象
        }
            // init();
        static once_flag once;//定义一次性标志
        call_once(once, &Log::init);//使用 call_once 确保初始化函数只被调用一次
        return *log;// 返回单例对象的引用
    }

    static void init()
    {
        if (!log)
        {
            log = new Log;

        }
    }

    void PrintLog(string msg)
    {
        lock_guard<mutex>lock(log_mutex);//加锁，保证线程安全
        cout <<__TIME__<<' ' << msg << endl;
    }

private:
    static Log* log;//单例对象指针
    static mutex log_mutex;//互斥锁
};
Log* Log::log = nullptr;//静态成员变量必须在类外进行定义
mutex Log::log_mutex; //静态成员变量必须在类外进行定义

void print_error()
{
    Log::GetInstance().PrintLog("error");//获取单例对象并打印错误日志
}

int main()
{
    thread t1(print_error);
    thread t2(print_error);
    thread t3(print_error);
    t1.join();
    t2.join();
    t3.join();
    return 0;
}

//饿汉模式
#include <iostream>
#include <thread>
#include <mutex>
#include <string>
using namespace std;

class Log
{
public:
    Log(const Log& log) = delete; // 禁用复制构造函数
    Log& operator=(const Log& log) = delete; // 禁用赋值操作符

    static Log& GetInstance() // 获取单例对象的接口
    {
        return log; // 直接返回单例对象
    }

    void PrintLog(string msg) // 打印日志的接口
    {
        lock_guard<mutex> lock(log_mutex); // 使用 RAII 锁保证线程安全
        cout << __TIME__ << ' ' << msg << endl; // 打印日志
    }

private:
    Log() {}; // 默认构造函数必须为私有
    static Log log; // 饿汉模式，直接定义单例对象
    static mutex log_mutex; // 互斥锁，保证线程安全
};

Log Log::log; // 静态成员变量必须在类外进行定义
mutex Log::log_mutex; // 静态成员变量必须在类外进行定义

void print_error() // 打印错误日志的函数
{
    Log::GetInstance().PrintLog("error"); // 获取单例对象并打印错误日志
}

int main()
{
    thread t1(print_error); // 创建打印错误日志的线程对象
    thread t2(print_error); // 创建打印错误日志的线程对象
    thread t3(print_error); // 创建打印错误日志的线程对象
    t1.join(); // 等待线程执行完成
    t2.join(); // 等待线程执行完成
    t3.join(); // 等待线程执行完成
    return 0;
}