单例模式是什么？
单例模式是一种创建型的软件设计模式。通过单例模式的设计，使得创建的类在当前进程中只有唯一一个实例，并提供一个全局性的访问点，这样可以规避因频繁创建对象而导致的内存飙升情况。
单例模式有三个要点
- 私有化构造函数：这样外界就无法自由地创建类对象，进而阻止了多个实例的产生。
- 类定义中含有该类的唯一静态私有对象：静态变量存放在全局存储区，且是唯一的，供所有对象使用。
- 用公有的静态函数来获取该实例：提供了访问接口。
基础代码
h文件：
//
// Created by qiaowei on 2023-12-25.
//
#ifndef RADARDATACONTROLLER_MAIN_WINDOW_HANDLER_H
#define RADARDATACONTROLLER_MAIN_WINDOW_HANDLER_H
#include <QObject>
namespace handler {
class MainWindowHandler : public QObject{
public:
virtual ~MainWindowHandler() override;
static MainWindowHandler* instance();
private:
explicit MainWindowHandler(QObject* parent = nullptr);
private:
/**
* @date 2023-12-25 19:32
* @author qiao wei
* @brief MainwindowHandler实例指针。static函数只能访问静态成员变量或函数，所以必须为static
*/
static MainWindowHandler* instance_;
};
} // handler
#endif //RADARDATACONTROLLER_MAIN_WINDOW_HANDLER_H
cpp文件：
//
// Created by qiaowei on 2023-12-25.
//
#include "main_window_handler.h"
namespace handler {
// 静态非const整型成员变量必须在类外定义。
MainWindowHandler* MainWindowHandler::instance_ = nullptr;
MainWindowHandler::MainWindowHandler(QObject* parent) : QObject(parent) {}
MainWindowHandler::~MainWindowHandler() {}
MainWindowHandler* MainWindowHandler::instance() {
if (nullptr == instance_) {
instance_ = new MainWindowHandler{nullptr};
}
return instance_;
}
} // handler单例模式一般分为懒汉式和饿汉式。
单例模式的基础代码不符合线程安全，因此引出了懒汉式和饿汉式单例模式。懒汉式：指全局的单例实例在第一次被使用时构建。饿汉式：全局的单例实例在类装载（ClassLoader）时构建(饿汉式单例性能优于懒汉式单例）。
懒汉式和饿汉式的区别：
- 懒汉式默认不会实例化，外部什么时候调用什么时候new。饿汉式在类加载的时候就实例化，并且创建单例对象。
- 懒汉式是延时加载，在需要的时候才创建对象，而饿汉式是在虚拟机启动的时候就会创建。
- 懒汉式在多线程中是线程不安全的，而饿汉式是不存在多线程安全问题的。
懒汉单例模式（需要时再实例化单例对象）
懒汉模式中使用QMutex，QMutexLocker进行同步锁。
h文件：
//
// Created by qiaowei on 2023-12-25.
//
#ifndef RADARDATACONTROLLER_MAIN_WINDOW_HANDLER_H
#define RADARDATACONTROLLER_MAIN_WINDOW_HANDLER_H
#include <QObject>
namespace handler {
class MainWindowHandler : public QObject{
public:
/**
* @date 2023-12-25 21:54
* @author qiao wei
* @version 1.0
* @brief 拷贝构造函数。删除拷贝构造，防止对象通过拷贝构造创建对象。
* @param
* @return
* @throws
*/
MainWindowHandler(const MainWindowHandler& value) = delete;
virtual ~MainWindowHandler() override;
/**
* @date 2023-12-25 21:56
* @author qiao wei
* @version 1.0
* @brief 赋值操作符。删除赋值操作符，防止简单类型通过赋值创建对象。
* @param
* @return
* @throws
*/
MainWindowHandler& operator=(const MainWindowHandler& value) = delete;
/**
* @date 2023-12-25 21:47
* @author qiao wei
* @version 1.0
* @brief 返回MainWindowHandler*指针的static函数。
* @param
* @return Mainwindow*指针。
* @throws
*/
static MainWindowHandler* instance();
private:
explicit MainWindowHandler(QObject* parent = nullptr);
private:
/**
* @date 2023-12-25 19:32
* @author qiao wei
* @brief MainwindowHandler实例指针。
*/
static MainWindowHandler* instance_;
static QMutex mutex_;
};
} // handler
#endif //RADARDATACONTROLLER_MAIN_WINDOW_HANDLER_H
cpp文件：
//
// Created by qiaowei on 2023-12-25.
//
#include <QMutexLocker>
#include <QMutex>
#include "main_window_handler.h"
namespace handler {
// 静态成员在类外初始化。
MainWindowHandler* MainWindowHandler::instance_ = nullptr;
QMutex MainWindowHandler::mutex_;
MainWindowHandler::~MainWindowHandler() {
delete instance_;
instance_ = nullptr;
}
MainWindowHandler* MainWindowHandler::instance() {
// 第1次检查：实例化单例对象后，就不会再进入加锁逻辑。
if (nullptr == instance_) {
// 加同步锁。
QMutexLocker mutex_locker(&mutex_);
// 第2次检查：可能2个线程同时通过第1次检查，1个线程获得锁时，可能另外1个线程已经实例化单体。
if (nullptr == instance_) {
instance_ = new MainWindowHandler{nullptr};
}
}
return instance_;
}
MainWindowHandler::MainWindowHandler(QObject* parent) : QObject(parent) {}
} // handler饿汉单例模式（一开始就初始化单例对象）
饿汉模式一
饿汉模式一缺点：不会调用析构函数，需要手动delete。
h文件
//
// Created by qiaowei on 2023-12-25.
//
#ifndef RADARDATACONTROLLER_EAGER_SINGLETON_H
#define RADARDATACONTROLLER_EAGER_SINGLETON_H
#include <QObject>
namespace handler {
class EagerSingleton : public QObject{
public:
virtual ~EagerSingleton() override;
static EagerSingleton* instance();
private:
explicit EagerSingleton(QObject* parent = nullptr);
private:
static EagerSingleton* instance_;
};
} // handler
#endif //RADARDATACONTROLLER_EAGER_SINGLETON_H
cpp文件
//
// Created by qiaowei on 2023-12-25.
//
#ifndef RADARDATACONTROLLER_EAGER_SINGLETON_H
#define RADARDATACONTROLLER_EAGER_SINGLETON_H
#include <QObject>
namespace handler {
class EagerSingleton : public QObject{
public:
virtual ~EagerSingleton() override;
static EagerSingleton* instance();
private:
explicit EagerSingleton(QObject* parent = nullptr);
private:
static EagerSingleton* instance_;
};
} // handler
#endif //RADARDATACONTROLLER_EAGER_SINGLETON_H
饿汉模式二
h文件
//
// Created by qiaowei on 2023-12-25.
//
#ifndef RADARDATACONTROLLER_EAGER_SINGLETON_2_H
#define RADARDATACONTROLLER_EAGER_SINGLETON_2_H
#include <QObject>
namespace handler {
class EagerSingleton2 : public QObject{
public:
static EagerSingleton2* instance();
virtual ~EagerSingleton2();
private:
explicit EagerSingleton2(QObject* parent = nullptr);
private:
static EagerSingleton2 eager_singleton_;
};
} // handler
#endif //RADARDATACONTROLLER_EAGER_SINGLETON_2_H
cpp文件
//
// Created by qiaowei on 2023-12-25.
//
#include "eager_singleton_2.h"
namespace handler {
EagerSingleton2 EagerSingleton2::eager_singleton_;
EagerSingleton2* EagerSingleton2::instance() {
return &eager_singleton_;
}
EagerSingleton2::~EagerSingleton2() {}
EagerSingleton2::EagerSingleton2(QObject *parent) : QObject(parent) {}
} // handler饿汉模式总结：
由于在定义静态变量的时候实例化单例类，因此在类加载的时候就已经创建了单例对象，可确保单例对象的唯一性。
饿汉模式缺点：
无论系统运行时是否需要使用该单例对象，都会在类加载时创建对象，资源利用效率不高。
