定义

单例模式是一种创建型设计模式，其目的是确保一个类只有一个实例，并提供一个全局访问点。这样可以确保在整个应用程序中只存在一个实例，避免了多次实例化造成的资源浪费，并且提供了一个统一的访问点以便于对该实例的管理。

示例

#include <iostream>

class Singleton {
private:
    // 私有的静态成员变量，用于保存唯一的实例
    static Singleton* instance;

    // 私有的构造函数，防止外部实例化
    Singleton() {
        std::cout << "Singleton instance created." << std::endl;
    }

public:
    // 静态的获取实例的方法
    static Singleton* getInstance() {
        // 如果实例不存在，则创建一个新的实例
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

    // 其他公有方法
    void someOperation() {
        std::cout << "Some operation performed." << std::endl;
    }

    // 防止复制和赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 在实际应用中可能需要添加析构函数，在程序结束时释放实例资源
    ~Singleton() {
        std::cout << "Singleton instance destroyed." << std::endl;
    if(instance)
        {
            delete instance;
        }
    }
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;

int main() {
    // 获取单例实例
    Singleton* singletonInstance1 = Singleton::getInstance();
    Singleton* singletonInstance2 = Singleton::getInstance();

    // 输出实例地址，用于验证是否是同一个实例
    std::cout << "Instance 1 address: " << singletonInstance1 << std::endl;
    std::cout << "Instance 2 address: " << singletonInstance2 << std::endl;

    // 调用实例方法
    singletonInstance1->someOperation();
    singletonInstance2->someOperation();

    // 注意：在实际应用中不需要手动释放单例实例，程序结束时会自动调用析构函数释放资源

    return 0;
}

这个示例中，Singleton 类有一个私有的静态成员变量 instance，用于保存唯一的实例。构造函数是私有的，通过静态的 getInstance() 方法获取实例，如果实例不存在，则在这个方法中创建一个新的实例。这确保了在整个应用程序中只存在一个实例。

在 main 函数中，通过调用 getInstance() 获取实例，并输出实例地址，验证是否是同一个实例。然后调用实例的方法，演示了单例模式的用法。最后，注意在实际应用中，不需要手动释放单例实例，因为在程序结束时会自动调用析构

注意点

单例的创建优化

static Singleton* getInstance() {
        // 如果实例不存在，则创建一个新的实例
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

上述示例的创建，并不是多线程安全的。当同时有两个线程都进入了 if (instance == nullptr) 条件，就有可能创建两次。

加锁

#include <iostream>
#include <mutex> // 包含互斥锁的头文件

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mutex; // 声明互斥锁

    Singleton() {
        std::cout << "Singleton instance created." << std::endl;
    }

public:
    static Singleton* getInstance() {
        // 使用互斥锁保证多线程安全
        std::lock_guard<std::mutex> lock(mutex);

        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

    void someOperation() {
        std::cout << "Some operation performed." << std::endl;
    }

    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    ~Singleton() {
        std::cout << "Singleton instance destroyed." << std::endl;
        if(instance)
        {
            delete instance;
        }
    }
};

Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

在上述示例中，引入了一个静态的 std::mutex 类型的成员变量 mutex，并在 getInstance() 方法中使用 std::lock_guard 对 mutex 进行加锁操作。这样就保证了在任何时刻只有一个线程可以进入 getInstance() 方法，从而避免了多线程环境下的竞态条件问题，保证了单例模式在多线程环境下的正确性。

但是还是存在问题，这里是读取资源，加锁代价会过高

双重检查锁

使用双重检查锁（double-checked locking）机制。双重检查锁可以在保证线程安全的同时，尽量减小锁的粒度，从而提高性能。

#include <iostream>
#include <mutex>

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mutex; // 声明互斥锁

    Singleton() {
        std::cout << "Singleton instance created." << std::endl;
    }

public:
    static Singleton* getInstance() {
        if (instance == nullptr) { // 第一次检查，避免不必要的加锁
            std::lock_guard<std::mutex> lock(mutex); // 加锁

            // 双重检查，防止多个线程同时通过第一次检查
            if (instance == nullptr) {
                instance = new Singleton();
            }
        }
        return instance;
    }

    void someOperation() {
        std::cout << "Some operation performed." << std::endl;
    }

    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    ~Singleton() {
        std::cout << "Singleton instance destroyed." << std::endl;
        if(instance)
        {
            delete instance;
        }
    }
};

Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

在这个优化版本中，首先进行了一个简单的检查，如果 instance 不为空，则无需加锁，直接返回实例。只有当 instance 为空时才会加锁进行双重检查，确保只有一个线程能够创建实例。

双重检查锁的机制可以在多线程环境下保证高效的单例模式实现，并且相比直接加锁的方式，减小了锁的粒度，降低了性能开销。

但是对象的创建存在reorder情况

使用 C++11 的 std::call_once 和 std::once_flag

继续改进

#include <iostream>
#include <mutex>

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mutex; // 声明互斥锁

    Singleton() {
        std::cout << "Singleton instance created." << std::endl;
    }

public:
    static Singleton* getInstance() {
        
         static std::once_flag oc;
    std::call_once(oc, [&]
                   { instance = new Singleton(); }); // ensure funtion only runninng one
        return instance;
    }

    void someOperation() {
        std::cout << "Some operation performed." << std::endl;
    }

    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    ~Singleton() {
        std::cout << "Singleton instance destroyed." << std::endl;
        if(instance)
        {
            delete instance;
        }
    }
};

Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

static Singleton* getInstance() {
    static std::once_flag oc;
    std::call_once(oc, [&]
                   { instance = new Singleton(); }); // 确保函数只运行一次
    return instance;
}

这是一种使用 C++11 的 std::call_once 和 std::once_flag 实现的线程安全的单例模式创建方式

1. std::once_flag： std::once_flag 是 C++11 引入的标准库类型，用于确保在多线程环境中，相关代码仅执行一次。它被用来保护 std::call_once 中的 lambda 表达式。

2. std::call_once： 这是一个 C++11 提供的函数，用于保证在多线程环境中，其内部的代码只会执行一次。它接受一个 std::once_flag 对象和一个可调用对象（如 lambda 表达式）作为参数。在第一次调用 std::call_once 时，会执行传入的可调用对象，之后的调用将不再执行。

3. Lambda 表达式： 传递给 std::call_once 的 lambda 表达式是一个匿名函数，其中包含了对象的创建逻辑。在这个例子中，lambda 表达式使用 new 运算符创建一个 Singleton 对象，并将其赋值给 instance。

4. 返回实例： 最后，getInstance 返回 instance 指针。由于 std::call_once 保证其中的代码只运行一次，因此在多线程环境中，多个线程调用 getInstance 也只会创建一个 Singleton 实例。

这种实现方式确保了懒加载（即在需要时才创建实例）和线程安全。如果多个线程同时尝试访问 getInstance，只有一个线程会成功创建实例，其他线程会等待创建完成后获得实例。这有助于避免竞态条件和不必要的实例创建。

应用示例

想象一下，一个国家只能同时有一个总统。总统代表国家，有严格的安全要求，因此只能有一个实例。这就类似于单例模式，其中总统是一个类，而总统的实例是一个单例对象。

映射到 C++ 中：

1. 定义总统类（President）

首先，我们定义一个 President 类来代表总统。这个类可能有一些私有成员和公共方法，用于表示总统的属性和行为。

class President {
private:
    // 私有构造函数，防止外部实例化
    President() {}

    // 防止复制和赋值
    President(const President&);
    President& operator=(const President&);

public:
    // 公共静态方法，返回总统实例
    static President& getInstance() {
       // static President instance;
         static std::once_flag oc;
      std::call_once(oc, [&]
                   { instance = new Singleton(); }); // 确保函数只运行一次
        return instance;
    }

    // 其他公共方法，用于总统的行为
    void deliverSpeech() {
        // 实现发表演讲的逻辑
    }

    // 其他方法...
};

2. 使用总统类

现在，我们可以在程序的其他地方使用 President 类来获取总统的实例，并调用其方法。

int main() {
    President& president = President::getInstance();
    president.deliverSpeech();
    // 其他操作...
    return 0;
}

解释：

1. 单一实例： President 类保证只有一个实例存在，这就是当前的总统。

2. 全局访问点： 通过 President 类的静态成员函数 getInstance() 可以获得总统的实例。这个函数提供了全局的访问点，使得任何地方都可以获取到总统的实例。

3. 线程安全： 在 C++11 及以上版本中，使用静态局部变量确保了 President 类的单一实例是线程安全的。因为静态局部变量只会在首次访问时进行初始化，而且 C++11 提供的线程安全的初始化保证了多线程环境下的安全性。

总的来说，President 类通过单例模式的设计确保了只有一个总统实例存在，并提供了全局的访问点，以便在程序的任何地方都可以访问到该实例。