c++单例设计模式---17

谁践踏了优雅 2021-09-17 12:36 127阅读 0赞

原创博文,转载请标明出处--*周学伟 * http://www.cnblogs.com/zxouxuewei/

全局变量在项目中是能不用就不用的，它是一个定时炸弹，是一个不安全隐患，特别是在多线程程序中，会有很多的不可预测性；同时，使用全局变量，也不符合面向对象的封装原则，所以，在纯面向对象的语言Java和C\#中，就没有纯粹的全局变量。那么，如何完美的解决这个日志问题，就需要引入设计模式中的单例模式。

何为单例模式，在GOF的《设计模式：可复用面向对象软件的基础》中是这样说的：保证一个类只有一个实例，并提供一个访问它的全局访问点。首先，需要保证一个类只有一个实例；在类中，要构造一个实例，就必须调用类的构造函数，如此，为了防止在外部调用类的构造函数而构造实例，需要将构造函数的访问权限标记为protected或private；最后，需要提供要给全局访问点，就需要在类中定义一个static函数，返回在类内部唯一构造的实例。意思很明白，使用UML类图表示如下。

![831155-20170406102201113-1259199478.png][]

**单例模式的优点：**

单例模式（Singleton）会控制其实例对象的数量，从而确保访问对象的唯一性。

1.  实例控制：单例模式防止其它对象对自己的实例化，确保所有的对象都访问一个实例。
2.  伸缩性：因为由类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。

**单例模式的缺点：**

1.  系统开销。虽然这个系统开销看起来很小，但是每次引用这个类实例的时候都要进行实例是否存在的检查。这个问题可以通过静态实例来解决。
2.  开发混淆。当使用一个单例模式的对象的时候（特别是定义在类库中的），开发人员必须要记住不能使用new关键字来实例化对象。因为开发者看不到在类库中的源代码，所以当他们发现不能实例化一个类的时候会很惊讶。
3.  对象生命周期。单例模式没有提出对象的销毁。在提供内存管理的开发语言（比如，基于.NetFramework的语言）中，只有单例模式对象自己才能将对象实例销毁，因为只有它拥有对实例的引用。在各种开发语言中，比如C++，其它类可以销毁对象实例，但是这么做将导致单例类内部的指针指向不明。

**单例适用性**

１．使用Singleton模式有一个必要条件：在一个系统要求一个类只有一个实例时才应当使用单例模式。反之，如果一个类可以有几个实例共存，就不要使用单例模式。

２．不要使用单例模式存取全局变量。这违背了单例模式的用意，最好放到对应类的静态成员中。

３．不要将数据库连接做成单例，因为一个系统可能会与数据库有多个连接，并且在有连接池的情况下，应当尽可能及时释放连接。Singleton模式由于使用静态成员存储类实例，所以可能会造成资源无法及时释放，带来问题。

**代码实现**

*实现一：*

#include <iostream>
    using namespace std;
    
    class Singleton
    {
         
    public:
        static Singleton *GetInstance()//获取单例instance
        {
         
            if (m_Instance == NULL )//判断是否已经创建单例对象
            {
         
                m_Instance = new Singleton ();
            }
            return m_Instance;
        }
    
        static void DestoryInstance()//单例销毁
        {
         
            if (m_Instance != NULL )//判断对象是否已经销毁
            {
         
                delete m_Instance;
                m_Instance = NULL ;
            }
        }
    
        // 操作方法实现
        int GetTest()
        {
         
            return m_Test;
        }
    
    private:
        Singleton(){ m_Test = 10; }
        static Singleton *m_Instance;
        int m_Test;
    };
    
    Singleton *Singleton ::m_Instance = NULL;
    
    
    
    int main(int argc , char *argv [])
    {
         
        Singleton *singletonObj = Singleton ::GetInstance();
        cout<<singletonObj->GetTest()<<endl;
    
        Singleton ::DestoryInstance();
        return 0;
    }

运行结果：

![831155-20170406103057613-967374556.png][]

这是最简单，也是最普遍的实现方式，但是，这种实现方式，有很多问题，比如：没有考虑到多线程的问题，在多线程的情况下，就可能创建多个Singleton实例，以下版本是改善的版本。

*　　**实现二：*

文件singleton.cpp
    
    #include <iostream>
    #include "boost/thread/thread.hpp"  
     
    
    using namespace std;
    boost::mutex lock; //C++没有直接的Lock操作，此处使用Boost库，仅为了说明
    
    class Singleton
    {
    public:
        static Singleton *GetInstance()
        {
            if (m_Instance == NULL )//双检锁机制（加入双检锁机制，防止大量线程被阻塞）
            {
                lock.lock(); //加锁防止多线程创建多个实例
                if (m_Instance == NULL )
                {
                    m_Instance = new Singleton ();
                }
                lock.unlock(); 
            }
            return m_Instance;
        }
    
        static void DestoryInstance()
        {
            if (m_Instance != NULL )
            {
                delete m_Instance;
                m_Instance = NULL ;
            }
        }
    　　//操作方法
        int GetTest()
        {
            return m_Test;
        }
    
    private:
        Singleton(){ m_Test = 0; }
        static Singleton *m_Instance;
        int m_Test;
    };
    
    Singleton *Singleton ::m_Instance = NULL;
    
    int main(int argc , char *argv [])
    {
        Singleton *singletonObj = Singleton ::GetInstance();
        cout<<singletonObj->GetTest()<<endl;
        Singleton ::DestoryInstance();
    
        return 0;
    }

Makefile如下：
    
    SRC_OBJ=singleton.o 
    SRC_BIN=singleton.bin 
    
    CXX=g++
    SRC_LIB=-lboost_system -lboost_filesystem 
    
    ${SRC_BIN} : ${SRC_OBJ}
        ${CXX} -o $@ $^ ${SRC_LIB}
    
    clean:
        ${RM} ${SRC_OBJ} ${SRC_BIN} *.o

运行如下：

![831155-20170406105745457-1389686946.png][]

此处进行了两次m\_Instance == NULL的判断，是借鉴了Java的单例模式实现时，使用的所谓的“双检锁”机制。因为进行一次加锁和解锁是需要付出对应的代价的，而进行两次判断，就可以避免多次加锁与解锁操作，同时也保证了线程安全。但是，这种实现方法在平时的项目开发中用的很好，也没有什么问题？但是，如果进行大数据的操作，加锁操作将成为一个性能的瓶颈；为此，一种新的单例模式的实现也就出现了。

*实现三：*

#include <iostream>
    using namespace std;
    
    class Singleton
    {
    public:
        static Singleton *GetInstance()
        {
            return const_cast <Singleton *>(m_Instance);
        }
    
        static void DestoryInstance()
        {
            if (m_Instance != NULL )
            {
                delete m_Instance;
                m_Instance = NULL ;
            }
        }
    
        int GetTest()
        {
            return m_Test;
        }
    
    private:
        Singleton(){ m_Test = 10; }
        static const Singleton *m_Instance;
        int m_Test;
    };
    
    //进入主函数之前，由主线程以单线程方式完成了初始化
    const Singleton *Singleton ::m_Instance = new Singleton();
    
    int main(int argc , char *argv [])
    {
        Singleton *singletonObj = Singleton ::GetInstance();
        cout<<singletonObj->GetTest()<<endl;
        Singleton ::DestoryInstance();
    }

运行如下：

![831155-20170406110319707-973492707.png][]

因为静态初始化在程序开始时，也就是进入主函数之前，由主线程以单线程方式完成了初始化，所以静态初始化实例保证了线程安全性。在性能要求比较高时，就可以使用这种方式，从而避免频繁的加锁和解锁造成的资源浪费。由于上述三种实现，都要考虑到实例的销毁，关于实例的销毁，待会在分析。由此，就出现了第四种实现方式：

*实现四：*

#include <iostream>
    using namespace std;
    
    class Singleton
    {
    public:
        static Singleton *GetInstance()
        {
            //没有使用new在堆上动态申请内存，直接在数据区申请空间，无需delet函数释放内存
            static Singleton m_Instance;
            return &m_Instance;//智能指针获取
        }
    
        int GetTest()
        {
            return m_Test++;
        }
    
    private:
        Singleton(){ m_Test = 10; };
        int m_Test;
    };
    
    int main(int argc , char *argv [])
    {
        Singleton *singletonObj = Singleton ::GetInstance();
        cout<<singletonObj->GetTest()<<endl;
    
        singletonObj = Singleton ::GetInstance();
        cout<<singletonObj->GetTest()<<endl;
    }

运行结果：

![831155-20170406110923878-141188900.png][]

对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷 贝，由该类型的所有对象共享访问。

也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共 用。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新；   
这里有篇文章，可以阅读以下：[http://anotherlayer.net/2012/05/04/static-initialization-and-thread-safety/][http_anotherlayer.net_2012_05_04_static-initialization-and-thread-safety]

#### 实例销毁 ####

在上述的四种方法中，除了第四种没有使用new操作符实例化对象以外，其余三种都使用了；我们一般的编程观念是，new操作是需要和delete操作进行匹配的；是的，这种观念是正确的。在上述的实现中，是添加了一个DestoryInstance的static函数，这也是最简单，最普通的处理方法了；但是，很多时候，我们是很容易忘记调用DestoryInstance函数，就像你忘记了调用delete操作一样。由于怕忘记delete操作，所以就有了智能指针；在实际项目中，其实是不在乎这个实例的销毁的。因为，全局就这么一个变量，全局都要用，它的生命周期伴随着软件的生命周期，软件结束了，它也就自然而然的结束了，因为一个程序关闭之后，它会释放它占用的内存资源的，所以，也就没有所谓的内存泄漏了。但是，有以下情况，是必须需要进行实例销毁的：

1.  在类中，有一些文件锁了，文件句柄，数据库连接等等，这些随着程序的关闭而不会立即关闭的资源，必须要在程序关闭前，进行手动释放；
2.  具有强迫症的程序员。

以上，就是我总结的两点。

虽然，在代码实现部分的第四种方法能满足第二个条件，加上析构函数能满足第一个条件。如下代码可以实现

#include <iostream>
    using namespace std;
    
    class Singleton
    {
    public:
        static Singleton *GetInstance()
        {
            return m_Instance;
        }
    
        int GetTest()
        {
            return m_Test;
        }
    
    private:
        Singleton(){ m_Test = 10; }
        static Singleton *m_Instance;
        int m_Test;
    
        
        class GC
        {
        public :
            ~GC()
            {
                // 我们可以早这里释放所有的资源
                if (m_Instance != NULL )
                {
                    cout<< "Here is the test" <<endl;
                    delete m_Instance;
                    m_Instance = NULL ;
                }
            }
        };
        static GC gc;
    };
    
    Singleton *Singleton ::m_Instance = new Singleton();
    Singleton ::GC Singleton ::gc;
    
    int main(int argc , char *argv [])
    {
        Singleton *singletonObj = Singleton ::GetInstance();
        cout<<singletonObj->GetTest()<<endl;
    
        return 0;
    }

在程序运行结束时，系统会调用Singleton的静态成员GC的析构函数，该析构函数会进行资源的释放，而这种资源的释放方式是在程序员“不知道”的情况下进行的，而程序员不用特别的去关心，使用单例模式的代码时，不必关心资源的释放。

那么这种实现方式的原理是什么呢？

由于程序在结束的时候，系统会自动析构所有的全局变量，实际上，系统也会析构所有类的静态成员变量，就像这些静态变量是全局变量一样。我们知道，静态变量和全局变量在内存中，都是存储在静态存储区的，所以在析构时，是同等对待的。

[831155-20170406102201113-1259199478.png]: /images/20210726/b60460a6965a470fb989c234abf2ac00.png
[831155-20170406103057613-967374556.png]: /images/20210726/ea967e86b59643689724f114b1377cde.png
[831155-20170406105745457-1389686946.png]: /images/20210726/83a7beaafeed4c83a3b5d819f6f6bbdf.png
[831155-20170406110319707-973492707.png]: /images/20210726/210611a5c25b4342aea39d37a019c532.png
[831155-20170406110923878-141188900.png]: /images/20210726/79ec7e6e9854416b80b321f0e612ba98.png
[http_anotherlayer.net_2012_05_04_static-initialization-and-thread-safety]: http://anotherlayer.net/2012/05/04/static-initialization-and-thread-safety/