C++单例模式以及线程安全

灰太狼 2022-09-26 02:40 195阅读 0赞

**写一个单例模式：**

class MySingleton
    {
    public:
          static MySingleton * GetInstance()
          //static method that returns only instance of MySingletone
          {
                if (m_pOnlyOneInstance == NULL) // if not yet instantiated
                {
                      m_pOnlyOneInstance = new MySingleton();
                      //create one and only object
                }
    
                return m_pOnlyOneInstance;
          }
    
    private:
    
          static MySingleton * m_pOnlyOneInstance;
          //holds one and only object of MySingleton
    
          MySingleton(); // private constructor
    
    public:
          // MySingleton functionalities
          void foo();
          bool goo();
          int zoo();
    };

**临界区实现线程安全：**

MySingleton * GetInstance() //usage of critcal section makes it thread safe
    {
          EnterCriticalSection();
          //other client threads, if any, now have to wait till current
          // thread leaves critical section. Forget semantics and
          // compilation for Crit Section, and treat this as pseudo-code
          if (m_pOnlyOneInstance == NULL)
          {
              m_pOnlyOneInstance = new MySingleton();
          }
    
          LeaveCriticalSection();
    
          return m_pOnlyOneInstance;
    }

**互斥量实现线程安全（boost）：**

#ifndef SINGLETON_H_
    #define SINGLETON_H_
    
    #include <cassert>
    #include <boost/thread/mutex.hpp>
    
    template<class T>
    class Singleton
    {
    public:
      static T& GetInstance()
      {
        assert(!is_destructed);
        (void)is_destructed; // prevent removing is_destructed in Release configuration
    
        boost::mutex::scoped_lock lock(GetMutex());
        static T instance;
        return instance;
      }
    
    private:
      static bool is_destructed;
    
      static boost::mutex& GetMutex()
      {
        static boost::mutex mutex;
        return mutex;
      }
    
      Singleton() {}
      ~Singleton() { is_destructed = true; }
    };
    
    // force creating mutex before main() is called
    template<class T>
    bool Singleton<T>::is_destructed = (Singleton<T>::GetMutex(), false);
    
    #endif // SINGLETON_H_

**互斥量实现线程安全（c++11）：**

#include <iostream>
    #include <atomic>
    #include <mutex>
    using namespace std;
    
    class Foo {
    public:
        static Foo* Instance();
    private:
        Foo() {init();}
        void init() { cout << "init done." << endl;} // your init cache function.
        static atomic<Foo*> pinstance;
        static mutex m_;
    };
    
    atomic<Foo*> Foo::pinstance { nullptr };
    std::mutex Foo::m_;
    
    Foo* Foo::Instance() {
      if(pinstance == nullptr) {
        lock_guard<mutex> lock(m_);
        if(pinstance == nullptr) {
            pinstance = new Foo();
        }
      }
      return pinstance;
    }
    
    
    
    int main() {
        Foo* foo1 = Foo::Instance();
        Foo* foo2 = Foo::Instance();
        return 0;
    }

**std::call\_once() 智能指针实现线程安全：**

#include <memory>
    #include <mutex>
    
    class CSingleton
    {
    public:
        virtual ~CSingleton();
        static CSingleton& GetInstance();
    
    private:
        static std::unique_ptr<CSingleton> m_instance;
        static std::once_flag m_onceFlag;
        CSingleton(void);
        CSingleton(const CSingleton& src);
        CSingleton& operator=(const CSingleton& rhs);
    };
    
    std::unique_ptr<CSingleton> CSingleton::m_instance;
    std::once_flag CSingleton::m_onceFlag;
    
    CSingleton& CSingleton::GetInstance()
    {
        std::call_once(m_onceFlag,
            [] {
                m_instance.reset(new CSingleton);
        });
        return *m_instance.get();
    }