单例模式简介
单例模式指的是，无论怎么获取，永远只能得到该类类型的唯一一个实例对象，那么设计一个单例模型要满足下面三个条件：
- 构造函数和析构函数为private，禁止外部构造和析构
- 拷贝构造函数和赋值构造函数被删除，确保实例的唯一性
- 类中存在可以全局访问获取实例的静态方法
单例模式全局只需要创建一个对象，比较常用的就是日志类，在整个项目中，需要打印一些提示信息到控制台或者到日志文件中，对于这个日志打印实现，全局只需要一个日志类对象。
单例模式分类 ：
单例模式可以分类懒汉式和饿汉式，两者的区别子啊创建实例的时间不同：
- 懒汉式：程序运行时，实例并不存在；只有当需要使用该实例时，才会去创建并使用该实例（需要考虑线程安全问题）
- 饿汉式：程序一开始运行，就初始化创建实例，当需要时，直接调用即可（本身就线程安全，不存在多线程不安全问题）。
这里介绍了线程安全的简单概念
懒汉单例模式
学习设计模式，就要在优秀的项目中发现设计的精妙之处，这里以c++11重写的muduo库中的日志类为例：
Logger.h
cpp
#pragma once
#include <string>
#include "noncopyable.h"
// LOG_INFO("%s %d", arg1, arg2)
#define LOG_INFO(logmsgFormat, ...) \
do \
{ \
Logger &logger = Logger::instance(); \
logger.setLogLevel(INFO); \
char buf[1024] = {0}; \
snprintf(buf, 1024, logmsgFormat, ##__VA_ARGS__); \
logger.log(buf); \
} while (0)
#define LOG_ERROR(logmsgFormat, ...) \
do \
{ \
Logger &logger = Logger::instance(); \
logger.setLogLevel(ERROR); \
char buf[1024] = {0}; \
snprintf(buf, 1024, logmsgFormat, ##__VA_ARGS__); \
logger.log(buf); \
} while (0)
#define LOG_FATAL(logmsgFormat, ...) \
do \
{ \
Logger &logger = Logger::instance(); \
logger.setLogLevel(FATAL); \
char buf[1024] = {0}; \
snprintf(buf, 1024, logmsgFormat, ##__VA_ARGS__); \
logger.log(buf); \
exit(-1); \
} while (0)
#ifdef MUDEBUG
#define LOG_DEBUG(logmsgFormat, ...) \
do \
{ \
Logger &logger = Logger::instance(); \
logger.setLogLevel(DEBUG); \
char buf[1024] = {0}; \
snprintf(buf, 1024, logmsgFormat, ##__VA_ARGS__); \
logger.log(buf); \
} while (0)
#else
#define LOG_DEBUG(logmsgFormat, ...)
#endif
// 定义日志的级别 INFO ERROR FATAL DEBUG
enum LogLevel
{
INFO, // 普通信息
ERROR, // 错误信息
FATAL, // core dump信息
DEBUG, // 调试信息
};
// 输出一个日志类
class Logger : noncopyable
{
public:
// 获取日志唯一的实例对象 单例
static Logger &instance();
// 设置日志级别
void setLogLevel(int level);
// 写日志
void log(std::string msg);
private:
int logLevel_;
};Logger.c
cpp
#include <iostream>
#include "Logger.h"
#include "Timestamp.h"
// 获取日志唯一的实例对象 单例
//饿汉式 线程安全
Logger &Logger::instance()
{
static Logger logger;
return logger;
}
// 设置日志级别
void Logger::setLogLevel(int level)
{
logLevel_ = level;
}
// 写日志 [级别信息] time : msg
void Logger::log(std::string msg)
{
std::string pre = "";
switch (logLevel_)
{
case INFO:
pre = "[INFO]";
break;
case ERROR:
pre = "[ERROR]";
break;
case FATAL:
pre = "[FATAL]";
break;
case DEBUG:
pre = "[DEBUG]";
break;
default:
break;
}
// 打印时间和msg
std::cout << pre + Timestamp::now().toString() << " : " << msg << std::endl;我们观察到，Logger类继承了noncopyable这个类，其定义为：
cpp
/**
* noncopyable被继承后 派生类对象可正常构造和析构 但派生类对象无法进行拷贝构造和赋值构造
**/
class noncopyable
{
public:
noncopyable(const noncopyable &) = delete;
noncopyable &operator=(const noncopyable &) = delete;
// void operator=(const noncopyable &) = delete; // muduo将返回值变为void 这其实无可厚非
protected:
noncopyable() = default;
~noncopyable() = default;
};这里的构造函数和析构函数保持默认方式，并且为访问权限为protected;拷贝构造函数和赋值构造函数禁用，访问权限是public；
cpp
class Logger : noncopyable
{
public:
// 获取日志唯一的实例对象 单例
static Logger &instance();
// 设置日志级别
void setLogLevel(int level);
// 写日志
void log(std::string msg);
private:
int logLevel_;
};随后Logger继承了noncopyable，c++默认是私有继承，则Logger的所有成员变量和方法都是私有的了；拷贝构造和赋值构造被禁止；类中存在获取实例的静态方法；满足单例模式的三大条件。
我们将Logger类的实现简化，去掉设置日志级别，以及打印的详细信息，精简为：
cpp
class Logger
{
public:
// 获取日志唯一的实例对象 单例
static Logger& instance()
{
static Logger logger;
return logger;
}
// 写日志
void log(std::string msg)
{
std::cout << msg << std::endl;
}
private:
//默认构造和析构函数
//赋值构造和拷贝构造被禁止
};这种实现方式是静态局部变量的懒汉单例 ，这种方式在 C++11 下是线程安全的，推荐使用这种方式。
特点：
- 静态局部变量只在当前函数内有效，其他函数无法访问。
- 静态局部变量只在第一次被被调用时初始化，存储在静态存储区，生命周期从第一次被初始化到程序结束。
这里还有其他几种懒汉式单例线程安全的总结，请参考：
C++ 线程安全的单例模式总结
饿汉-单例模式
cpp
#include <iostream>
using namespace std;
class Logger
{
public:
static Logger& instance() {
return logger;
}
// 写日志
void log(std::string msg)
{
std::cout << __TIME__<<msg << std::endl;
}
static Logger logger; // 静态成员变量，程序启动时就创建
private:
//默认构造和析构函数
//赋值构造和拷贝构造被禁止
};
// 定义并初始化静态成员（在全局作用域中）
Logger Logger::logger;
int main()
{
Logger::instance().log("这是饿汉模式的测试");
return 0;
}饿汉模式天然线程安全：这是因为logger在程序加载阶段就会被初始化（静态初始化），不会涉及多个线程同时创建对象的问题。
总结：懒汉式是以时间换空间，适用于访问量较小时；饿汉式是以空间换时间，适用于访问量较大时，或者线程比较多的情况。