C++设计模式 - 单例模式（Singleton）

对象性能模式

面向对象很好地解决了"抽象”的问题，但是必不可免地要付出一定的代价。对于通常情况来讲,面向对象的成本大都可以忽略不计。但是某些情况,面向对象所带来的成本必须谨慎处理。

典型模式

  • Singleton

Singleton

单例模式其意图是：保证一个类只有一个实例，并提供一个访问它的全局访问点。

  • 为了防止外部类构造实例，需要将构造函数的访问权限标记为protected或private；
  • 需要提供全局访问点，就需要在类中定义一个static函数，返回在类内部唯一构造的实例。

线程非安全版本

#include 

class Singleton{
private:
    Singleton(){
        std::cout<<"constructor called!"<

线程安全版本，但锁的代价过高

#include 
#include 

class Singleton
{
private:
    Singleton()
    {
        std::cout << "constructor called!" << std::endl;
    }
    Singleton(Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;
    static Singleton *m_instance;
    static std::mutex m_mtx;

public:
    ~Singleton()
    {
        std::cout << "destructor called!" << std::endl;
    }
    static Singleton *get_instance()
    {
        std::lock_guard lk{m_mtx};
        if (m_instance == nullptr)
        {
            m_instance = new Singleton();
        }
        return m_instance;
    }
};

Singleton *Singleton::m_instance = nullptr;
std::mutex Singleton::m_mtx;

int main()
{
    Singleton *instance = Singleton::get_instance();
    Singleton *instance_2 = Singleton::get_instance();
    return 0;
}

双检查锁，但由于内存读写reorder不安全

#include 
#include 

class Singleton
{
private:
    Singleton()
    {
        std::cout << "constructor called!" << std::endl;
    }
    Singleton(Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;
    static Singleton *m_instance;
    static std::mutex m_mtx;

public:
    ~Singleton()
    {
        std::cout << "destructor called!" << std::endl;
    }
    static Singleton *get_instance()
    {
        if (m_instance == nullptr)
        {
            std::lock_guard lk{m_mtx};
            if (m_instance == nullptr)
            {
                m_instance = new Singleton();
            }
        }
        return m_instance;
    }
};

Singleton *Singleton::m_instance = nullptr;
std::mutex Singleton::m_mtx;

int main()
{
    Singleton *instance = Singleton::get_instance();
    Singleton *instance_2 = Singleton::get_instance();
    return 0;
}

线程安全、内存安全的（智能指针，锁）

#include 
#include 
#include 
class Singleton
{
public:
    typedef std::shared_ptr Ptr;
    ~Singleton()
    {
        std::cout << "destructor called!" << std::endl;
    }
    Singleton(Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;
    static Ptr get_instance()
    {
        if (m_instance_ptr == nullptr)
        {
            std::lock_guard lk(m_mutex);
            if (m_instance_ptr == nullptr)
            {
                m_instance_ptr = std::shared_ptr(new Singleton);
            }
        }
        return m_instance_ptr;
    }

private:
    Singleton()
    {
        std::cout << "constructor called!" << std::endl;
    }
    static Ptr m_instance_ptr;
    static std::mutex m_mutex;
};

Singleton::Ptr Singleton::m_instance_ptr = nullptr;
std::mutex Singleton::m_mutex;

int main()
{
    Singleton::Ptr instance = Singleton::get_instance();
    Singleton::Ptr instance2 = Singleton::get_instance();
    return 0;
}

使用静态局部变量安全又高效

#include 

class Singleton
{
public:
    ~Singleton()
    {
        std::cout << "destructor called!" << std::endl;
    }
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;
    static Singleton &get_instance()
    {
        static Singleton instance;
        return instance;
    }

private:
    Singleton()
    {
        std::cout << "constructor called!" << std::endl;
    }
};

int main(int argc, char *argv[])
{
    Singleton &instance_1 = Singleton::get_instance();
    Singleton &instance_2 = Singleton::get_instance();
    return 0;
}
设计模式单例模式单件模式

相关

设计模式十一：命令链模式

设计模式-结构型模式， mvc 模型视图控制器模式（8）

设计模式二：门面模式

设计模式八：单例模式

依赖注入[2]: 基于IoC的设计模式

Java进阶专题(九) 设计模式之总结

设计模式--中介者模式

PHP高级特性-反射Reflection以及Factory工厂设计模式的结合使用[代码实例]

javascript设计模式阅读后的感悟与总结

Java设计模式之（三）——建造者模式

0x00_设计模式

C# 设计模式之总结篇

标签