C++中的单例模式

我不是女神ヾ 2022-09-25 08:21 134阅读 0赞

## 一、什么是单例模式 ##

单例模式(Singleton Pattern，也称为单件模式)，使用最广泛的设计模式之一。其意图是保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

定义一个单例类，私有化它的构造函数，以防止外界创建单例类的对象；使用类的私有静态指针变量指向类的唯一实例，并用一个公有的静态方法获取该实例。

![640335-20160816223325593-524916303.png][]

## 二、懒汉版（Lazy Singleton） ##

**教学版**，即**懒汉版（Lazy Singleton）**：单例实例在第一次被使用时才进行初始化，这叫做延迟初始化。

// version 1.0
    class Singleton
    {
    private:
        static Singleton* instance;
    private:
        Singleton() {};
        ~Singleton() {};
        Singleton(const Singleton&);
        Singleton& operator=(const Singleton&);
    public:
        static Singleton* getInstance() {
            if(instance == NULL) {
                instance = new Singleton();
            }
            return instance;
        }
    };
    
    // init static member
    Singleton* Singleton::instance = NULL;

Lazy Singleton存在内存泄露的问题，这里有两种解决方法：

1.  使用智能指针
2.  使用静态的嵌套类对象

对于第二种解决方法，代码如下：

// version 1.1
    class Singleton
    {
    private:
        static Singleton* instance;
    private:
        Singleton() { };
        ~Singleton() { };
        Singleton(const Singleton&);
        Singleton& operator=(const Singleton&);
    private:
        class Deletor {
        public:
            ~Deletor() {
                if(Singleton::instance != NULL)
                    delete Singleton::instance;
            }
        };
        static Deletor deletor;
    public:
        static Singleton* getInstance() {
            if(instance == NULL) {
                instance = new Singleton();
            }
            return instance;
        }
    };
    
    // init static member
    Singleton* Singleton::instance = NULL;

在程序运行结束时，系统会调用静态成员`deletor`的析构函数，该析构函数会删除单例的唯一实例。使用这种方法释放单例对象有以下特征：

*  在单例类内部定义专有的嵌套类。
 *  在单例类内定义私有的专门用于释放的静态成员。
 *  利用程序在结束时析构全局变量的特性，选择最终的释放时机。

注意`version 1.0`与`version 1.1`都不是线程安全的，要使其线程安全，可以使用**双检测锁模式（Double-Checked Locking Pattern）**：

static Singleton* getInstance() {
        if(instance == NULL) {
            Lock lock;  // 基于作用域的加锁，超出作用域，自动调用析构函数解锁
            if(instance == NULL) {
                instance = new Singleton();
            }
        }
        return instance;
    }

在单例类内再定义一个嵌套类，总是感觉很麻烦，所以《Effective C++》（Item 04）中的提出另一种更优雅的单例模式实现，使用函数内的 local static 对象。当第一次访问`getInstance()`方法时才创建实例：

// version 1.2
    class Singleton
    {
    private:
        Singleton() { };
        ~Singleton() { };
        Singleton(const Singleton&);
        Singleton& operator=(const Singleton&);
    public:
        static Singleton& getInstance() {
            static Singleton instance;
            return instance;
        }
    };

C++0X以后，要求编译器保证内部静态变量的线程安全性，故C++0x之后该实现是线程安全的，C++0x之前仍需加锁。

## 三、饿汉版（Eager Singleton） ##

**饿汉版（Eager Singleton）：**指单例实例在程序运行时被立即执行初始化

// version 1.3
    class Singleton
    {
    private:
        static Singleton instance;
    private:
        Singleton();
        ~Singleton();
        Singleton(const Singleton&);
        Singleton& operator=(const Singleton&);
    public:
        static Singleton& getInstance() {
            return instance;
        }
    }
    
    // initialize defaultly
    Singleton Singleton::instance;

由于在main函数之前初始化，所以没有线程安全的问题。但是潜在问题在于no-local static对象（函数外的static对象）在不同编译单元中的初始化顺序是未定义的。如果在初始化完成之前调用 getInstance() 方法会返回一个未定义的实例。

总结：

*  Eager Singleton 虽然是线程安全的，但存在潜在问题；
 *  Lazy Singleton通常需要加锁来保证线程安全，但局部静态变量版本在C++11后是线程安全的；
 *  局部静态变量版本（Meyers Singleton）最优雅，面试时建议写这个版本。

--------------------

参考：  
\[1\] 单例模式的Java实现，请看CoolShell的《[深入浅出Singleton设计模式][Singleton]》  
\[2\] www.zkt.name/dan-li-mo-shi-singleton-ji-c-shi-xian

[640335-20160816223325593-524916303.png]: /images/20220718/1e88bc6bceb04c30b8ca9f7c484b3991.png
[Singleton]: http://coolshell.cn/articles/265.html