【设计模式】创建型模式之单例Singleton

不念不忘少年蓝@ 2022-08-21 12:50 212阅读 0赞

在设计模式中，单例Singleton是一种简单、常用的创建型模式，它的目的是保证一个类仅有一个实例，并提供一个访问它的全局访问点，下面以C++为例说明单例的使用。

## 1、一个简单的单例 ##

一个最一般的单例类图如下所示：

![这里写图片描述][20160502201055789]

如下Singleton类，使用了单例模式，仅仅对外部提供了一个访问接口，即public权限的静态成员函数Instance，与之相关联的是一个private权限的静态成员变量，用来保存唯一的类实例。为了保证外部无法创建一个类对象，这里的构造函数为private，同时也意味着阻止了类的子类化。另外还声明了拷贝构造函数和赋值操作符为private，并没有真正去定义实现它们，进一步阻止了外部的可操作性。

/* * @class Singleton */
    class Singleton
    {
    public:
        static Singleton* Instance();
    
    private:
        Singleton();
        Singleton(const Singleton&);
        Singleton& operator =(const Singleton&);
    
    private:
        static Singleton *s_self;
    };

下面是Singleton类的实现，初始化时并没有创建对象，而是在外部第一次通过Instance函数访问时才进行了实例化，这便是所谓的懒汉模式。

/* Singleton - lazy*/
    Singleton* Singleton::s_self = 0;
    
    Singleton* Singleton::Instance()
    {
        if (0 == s_self) {
            s_self = new Singleton;
        }
        return s_self;
    }
    
    Singleton::Singleton()
    {
    }

## 2、单例的子类化问题 ##

考虑到一个单例类作为基类，有可能被继承，上面的代码情形就不适用了，至少其构造函数应该为protected，这样外部无法实例化，派生类也获得了构造能力，但是实例化工作交给谁来做呢，显然不是外部对象，可以尝试在父类中完成，由父类统一管理，如下例子的SingletonBase类通过环境变量来判断需要真正实例化的对象是哪一个。

/* * @class SingletonBase */
    class SingletonBase
    {
    public:
        static SingletonBase* Instance();
    
    protected:
        SingletonBase();
    
    private:
        static SingletonBase *s_self;
    };
    
    /* * @class SingletonA */
    class SingletonA : public SingletonBase
    {
    private:
        friend class SingletonBase;
    
        SingletonA();
    };

下面是SingletonBase类和SingletonA类的实现部分。

/* SingletonBase */
    SingletonBase* SingletonBase::s_self = 0;
    
    /* uses env var */
    SingletonBase* SingletonBase::Instance()
    {
        if (0 == s_self) {
            const char *singletonName = getenv(ENV_SINGLETON);
            if (0 == singletonName) {
                s_self = new SingletonBase;
            }
            else {
                if (strcmp(singletonName, "SingletonA") == 0) {
                    s_self = new SingletonA;
                }
                else {
                    s_self = new SingletonBase;
                }
            }
        }
        return s_self;
    }
    
    SingletonBase::SingletonBase()
    {
    }
    
    /* SingletonA */
    SingletonA::SingletonA()
    {
    }

## 3、使用注册表 ##

上面例子的实例化工作交给了父类，但一个缺点也暴露了出来，那就是父类硬编码了好多东西，这并不是一种好的编程风格，不过还有一种更灵活的方式，即注册表。如下例子的SingletonRegistry类，提供了Register接口给子类使用，也就是说子类在实例化时调用Register接口向父类注册信息，信息是一个map对象，map的key为子类的唯一标识符，map的value为子类的实例对象，父类将这些信息保存下来，然后在给外部使用的Instance中通过环境变量来Lookup查找所需对象是否已经注册并返回相应的结果。这个地方的实例化工作并不是由父类完成的，父类只是负责保存注册信息并查找返回注册结果，对象创建可以在外部或者子类中完成，例子中把实例化工作交给了子类，初始化时已经完成，这就是所谓的饥饿模式。实例化工作还可以在其它合适的地方创建一个static变量，保证注册工作先与Instance调用。

/* * @class SingletonRegistry */
    class SingletonRegistry
    {
    public:
        static SingletonRegistry* Instance();
    
    protected:
        static void Register(const std::string &name, SingletonRegistry *singleton);
    
        SingletonRegistry();
    
    private:
        static SingletonRegistry* Lookup(const std::string &name);
    
    private:
        static SingletonRegistry* s_self;
        static std::map<std::string, SingletonRegistry*> s_registry;
    };
    
    /* * @class SingletonB */
    class SingletonB : public SingletonRegistry
    {
    public:
        SingletonB();
    
    private:
        static SingletonB s_self;
    };

下面是实现部分，因为子类只能有一个实例，所以Register注册时作了判断，如果之前已经注册，程序将直接abort退出。

/* SingletonRegistry */
    SingletonRegistry* SingletonRegistry::s_self = 0;
    std::map<std::string, SingletonRegistry*> SingletonRegistry::s_registry;
    
    SingletonRegistry* SingletonRegistry::Instance()
    {
        if (0 == s_self) {
            const char *singletonName = getenv(ENV_SINGLETON);
            if (0 != singletonName) {
                s_self = Lookup(std::string(singletonName));
            }
        }
        return s_self;
    }
    
    void SingletonRegistry::Register(const std::string &name, SingletonRegistry *singleton)
    {
        if (s_registry.find(name) != s_registry.end()) {
            std::cout << name << " has been instantiated!" << std::endl;
            abort();
        }
        s_registry[name] = singleton;
    }
    
    SingletonRegistry::SingletonRegistry()
    {
    }
    
    SingletonRegistry* SingletonRegistry::Lookup(const std::string &name)
    {
        std::map<std::string, SingletonRegistry*>::iterator it = s_registry.find(name);
        if (s_registry.end() != it) {
            return it->second;
        }
        return 0;
    }
    
    /* SingletonB - hungry */
    SingletonB SingletonB::s_self;
    
    SingletonB::SingletonB()
    {
        SingletonRegistry::Register(std::string("SingletonB"), this);
    }

[20160502201055789]: /images/20220724/9e1f0fa9505a42cbb40870c4d40e5a88.png