单例模式简析

一、单例模式

     单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供这个实例。

     特点就是多读单写。

函数简单实现：

class Singleton

{

public :

        static Singleton *GetInstance() //申明为static，可以由对象直接调用，不用用类调用

       {

               if (_sInstance == NULL )

              {

                     _sInstance = new Singleton ;

              }

               return _sInstance;

       }

        void printf()

       {

              cout << _data << endl;

       }

protected :

       Singleton()

              :_data(0)

       {}

        //防拷贝,只申明不定义

       Singleton( Singleton &);

        Singleton &operator=( Singleton &);

        //指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例

        static Singleton * _sInstance;

private :

        int _data;

};

Singleton * Singleton ::_sInstance = NULL ; //初始化

int main()

{

        Singleton ::GetInstance()->printf();

        return 0;

}

二、基于线程安全的改进

     若有两个线程同时访问单例模式获取对象的方法，thread1执行方法，第一次进入发现指针为NULL，在还没有new之前，thread2也进入，这样就不能保证只有一个对象被创建，且第二个创建的对象将第一个创建的对象覆盖

解决方法：

     1、懒汉模式

     调用对象时才产生实例对象

 

改进

     static Singleton *GetInstance()

       {

               if (_sInstance == NULL ) //保证效率

              {

                     _mx.lock(); //保证线程安全

                      if (_sInstance == NULL )

                     {

                           _sInstance = new Singleton ;

                            //解法：RAII 2.用库函数的guard

                     }

                     _mx.unlock();

              }

               return _sInstance;

       }

     新增static成员对象

     static mutex _mx;

     在类外需要初始化

     mutex Singleton ::_mx

    

     但是，这么做有会引入新的问题，即当发生new失败时，则会发生抛异常， 而抛异常则会导致死锁。

     解决方法：可以使用RAII，自动析构，guard

     static Singleton *GetInstance()

       {

               if (_sInstance == NULL ) //保证效率

              {

                      lock_guard < mutex > lock(_mx);

                      if (_sInstance == NULL )

                     {

                           _sInstance = new Singleton ; //new 有可能会抛异常，若抛异常则导致死锁,但是用lock_guard可以出作用域自动析构

                     }

              }

               return _sInstance;

       }

     2、饿汉模式

     最开始就创建对象

     既线程安全，又高效

     指针为静态，在main函数之前初始化，

class Singleton

{

public :

        static Singleton *GetInstance()

       {

               assert (_sInstance);

              

               return _sInstance;

       }

        void printf()

       {

              cout << _data << endl;

       }

protected :

       Singleton()

              :_data(0)

       {}

        //防拷贝,只申明不定义

       Singleton( Singleton &);

        Singleton &operator=( Singleton &);

        //指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例

        static Singleton * _sInstance;

private :

        int _data;

};

Singleton * Singleton ::_sInstance = new Singleton ;

三、关于面试题

1、定义一个类，只能在堆上生成对象

     

class A

{

public :

        A *GetObj()

       {

               return new A ;

       }

private :

       A()

       {}

       A( const A &);

};

2、定义一个类，只能在栈上生成对象

     

class A

{

private :

        void *operator new ( size_t );

        void operator delete( void *p);

        void *operator new[]( size_t );

        void operator delete[]( void *p);

private :

        int a;

};