c++单例模式(Singleton)多种实现方式及最优比较

前言

关于C++单例模式的写法，大家都很熟悉。早期的设计模式中有代码示例。比如：

class Singleton {
    private: static Singleton *instance;

    public: static Singleton *getInstance() {
        if (NULL == instance)
            instance = new Singleton();

        return instance;
    }
};

它的缺点：线程不安全，指针资源没有释放。

自从C++11推出后，单例模式有了更优秀的写法，下面来介绍下。

使用 std::call_once 实现

#include <iostream>
#include <mutex>
#include <memory>
 
class Singleton {
private:
    Singleton() { std::cout << "Singleton constructed." << std::endl; }
    
    static std::once_flag initInstanceFlag;
    static std::unique_ptr<Singleton> instance;
 
    // 删除拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
 
public:
    static Singleton& getInstance() {
        std::call_once(initInstanceFlag, []() {
            instance.reset(new Singleton());
        });
        return *instance;
    }
 
    void someMethod() {
        std::cout << "Method of the singleton" << std::endl;
    }
 
    ~Singleton() {
        std::cout << "Singleton destructed." << std::endl;
    }
};
 
std::once_flag Singleton::initInstanceFlag;
std::unique_ptr<Singleton> Singleton::instance;
 
// 使用示例
void threadFunction() {
    Singleton& singleton = Singleton::getInstance();
    singleton.someMethod();
}
 
int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);
 
    t1.join();
    t2.join();
 
    return 0;
}

优点：线程安全、内存安全。显式控制初始化过程，适合需要延迟初始化的场景。

使用局部静态变量实现（C++11及以后）

#include <iostream>
#include <memory>
 
class Singleton {
private:
    Singleton() { std::cout << "Singleton constructed." << std::endl; }
 
    // 关闭拷贝构造函数、右值拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton(const Singleton &&) = delete;
    Singleton& operator=(const Singleton&) = delete;
 
public:
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }
 
    void someMethod() {
        std::cout << "Method of the singleton" << std::endl;
    }
 
    ~Singleton() {
        std::cout << "Singleton destructed." << std::endl;
    }
};
 
// 使用示例
void threadFunction() {
    Singleton& singleton = Singleton::getInstance();
    singleton.someMethod();
}
 
int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);
 
    t1.join();
    t2.join();
 
    return 0;
}

优点：线程安全。代码最简洁，由C++11标准保证线程安全，适合大多数场景。
缺点：适用于不复杂的工程。因为如果静态类之间有依赖，可能会导致C++的一些未定义的行为。

Meyers 的版本

Scott Meyers 是 Effective C++系列的作者，他最早提供了简洁版本的 Singletion 模型。根据他提供的模型，可以写出线程安全又简单的单例模式。代码如下：

#include <stdio.h>

class singleton {
  static singleton &instance() {
    static singleton instance;
    return instance;
  } // instance

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

private:
  singleton() {}
  ~singleton() {}

public:
  void out(){ printf("out\n"); }
}; // struct singleton

int main() {
    singleton::instance().out();
    return 0;
}

缺点：单一的实例总是在 main() 开始之前被初始化的，该实现无法做到 lazyinit。
优化版本：

 template<typename T>
 class singleton {
 public:
	 static T &instance();
	
	 singleton(const singleton &) = delete;
	 singleton &operator=(const singleton) = delete;
	
 protected:
	 singleton() = default;
 };

 template<typename T>
 inline T &singleton<T>::instance() {
   static const std::unique_ptr<T> instance{new T{token{}}};
   return *instance;
 }

优点：线程安全、内存安全。

鸿蒙单例实现

线程安全、内存安全、延迟加载、支持lazyinit、实现单例模板。当前在使用中，代码可靠。
使用说明，请点这里。
下面只展示DelayedSingleton实现示例。完整代码以及其它几种单例实现，请点这里。

template<typename T>
class DelayedSingleton : public NoCopyable {
public:
    static std::shared_ptr<T> GetInstance();
    static void DestroyInstance();

private:
    static std::shared_ptr<T> instance_;  instance.
    static std::mutex mutex_; 
};

template<typename T>
std::shared_ptr<T> DelayedSingleton<T>::instance_ = nullptr;

template<typename T>
std::mutex DelayedSingleton<T>::mutex_;

template<typename T>
std::shared_ptr<T> DelayedSingleton<T>::GetInstance()
{
    if (instance_ == nullptr) {
        std::lock_guard<std::mutex> lock(mutex_);
        if (instance_ == nullptr) {
            std::shared_ptr<T> temp(new (std::nothrow) T);
            instance_ = temp;
        }
    }

    return instance_;
}

template<typename T>
void DelayedSingleton<T>::DestroyInstance()
{
    std::lock_guard<std::mutex> lock(mutex_);
    if (instance_ != nullptr) {
        instance_.reset();
        instance_ = nullptr;
    }
}