单例模式是一种常见的设计模式，用于确保某个类只能创建一个实例。由于单例模式是全局唯一的，因此在多线程中使用单例模式时需要考虑线程安全问题。
1.GetInstance()实例化一个对象
- 懒汉式：第一次用到类的时候才会去实例化。
懒汉式创建对象的方法是在程序使用对象前，先判断该对象是否已经实例化（判空），若已实例化直接返回该类对象。，否则则先执行实例化操作。
- 饿汉式：在类的加载的时候就去实例化
饿汉式在类加载时已经创建好该对象，在程序调用时直接返回该单例对象即可，即我们在编码时就已经指明了要马上创建这个对象，不需要等到被调用时再去创建。
#include<iostream>
#include<thread>
#include<mutex>
#include<string>class Log {
public:Log() {};Log(const Log& log) = delete;Log& operator = (const Log& log) = delete;static Log& GetIntance(){static Log Log; //饿汉模式，提前声明一个对象，需要的时候直接给。return Log; }/*****************************static Log& GetIntance(){static Log *Log = nullptr; //懒汉模式，需要的时候再去创建一个对象。if(!Log) Log = new Log;return *Log;}
****************************/};void printfLog(std::string msg){std::cout<<msg<<std::endl;
}void func(std::string msg){Log::GetInstance().printLog("error!!!");
}int main(){std::thread t1(func);std::thread t1(func);t1.json;t2.json;Log::GetInstance().printLog("error!!!");
}==================================
2.多线程出现线程安全问题
t1和t2同时调用func函数，func函数调用GetInstance函数实例化一个对象，但是如果t1和t2同时new一个对象Log,当new的Log对象的地址还没来得及赋值给Log,t2又new了一个对象，这时就会出现错误。
代码实例如下：
#include<iostream>
#include<thread>
#include<mutex>
#include<string>class Log {
public:Log() {};Log(const Log& log) = delete;Log& operator = (const Log& log) = delete;
/***************************** static Log& GetIntance(){static Log Log; //饿汉模式，提前声明一个对象，需要的时候直接给。return Log; }
****************************/static Log& GetIntance(){static Log *Log = nullptr; //懒汉模式，需要的时候再去创建一个对象。if(!Log) Log = new Log;return *Log;}void printfLog(std::string msg){std::cout<<msg<<std::endl;
}};void func(std::string msg){Log::GetInstance().printLog("error!!!");}int main(){std::thread t1(func);std::thread t1(func);t1.json;t2.json;Log::GetInstance().printLog("error!!!");
}==================================
从性能线程上的区别：
1、线程安全：
饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题。
懒汉式本身是非线程安全的。
2、资源加载和性能：
饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内 存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成。
而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。
================================
3.call_once函数
在多线程中，有一种场景是某个任务只需要执行一次，可以用C++11中的std::call_once函数配合std::once_flag来实现。多个线程同时调用某个函数，std::call_once可以保证多个线程对该函数只调用一 次。
void call_once (once_flag& flag, Fn&& fn, Args&&...args);
第一个参数是std::once_flag的对象(once_flag是不允许修改的，其拷贝构造函数和operator=函数都声明为delete)，第二个参数可调用实体，即要求只执行一次的代码，后面可变参数是其参数列表。
call_once保证函数fn只被执行一次，如果有多个线程同时执行函数fn调用，则只有一个活动线程(active call)会执行函数，其他的线程在这个线程执行返回之前会处于”passive execution”(被动执行状态)——不会直接返回，直到活动线程对fn调用结束才返回。对于所有调用函数fn的并发线程，数据可见性都是同步的(一致的)。
如果活动线程在执行fn时抛出异常，则会从处于”passive execution”状态的线程中挑一个线程成为活动线程继续执行fn，依此类推。一旦活动线程返回，所有”passive execution”状态的线程也返回,不会成为活动线程。(实际上once_flag相当于一个锁，使用它的线程都会在上面等待，只有一个线程允许执行。如果该线程抛出异常，那么从等待中的线程中选择一个，重复上面的流程)。
代码实例如下：
#include<iostream>
#include<thread>
#include<mutex>
#include<string>static Log *Log = nullptr; //懒汉模式，需要的时候再去创建一个对象。
static std::once_flag once;class Log {
public:Log() {};Log(const Log& log) = delete;Log& operator = (const Log& log) = delete;/*****************************static Log& GetIntance(){static Log *Log = nullptr; //懒汉模式，需要的时候再去创建一个对象。if(!Log) Log = new Log;return *Log;}****************************/ static Log& GetIntance(){std::call_once(once,init);return *Log; }
};static void init()
{if(!Log) Log = new Log;
}void printfLog(std::string msg){std::cout<<msg<<std::endl;
}void func(std::string msg){Log::GetInstance().printLog("error!!!");
}int main(){std::thread t1(func);std::thread t1(func);t1.json;t2.json;Log::GetInstance().printLog("error!!!");
}
)
)
)
