详解C++实现线程安全的单例模式

在某些应用环境下面,一个类只允许有一个实例,这就是著名的单例模式。单例模式分为懒汉模式,跟饿汉模式两种。

首先给出饿汉模式的实现

正解:

template <class T>
class singleton
{
protected:
  singleton(){};
private:
  singleton(const singleton&){};//禁止拷贝
  singleton& operator=(const singleton&){};//禁止赋值
  static T* m_instance;
public:
  static T* GetInstance();
};
 
 
template <class T>
T* singleton<T>::GetInstance()
{
  return m_instance;
}
 
template <class T>

在实例化m_instance 变量时,直接调用类的构造函数。顾名思义,在还未使用变量时,已经对m_instance进行赋值,就像很饥饿的感觉。这种模式,在多线程环境下肯定是线程安全的,因为不存在多线程实例化的问题。

下面来看懒汉模式

template <class T>
class singleton
{
protected:
  singleton(){};
private:
  singleton(const singleton&){};
  singleton& operator=(const singleton&){};
  static T* m_instance;
public:
  static T* GetInstance();
};
 
 
template <class T>
T* singleton<T>::GetInstance()
{
  if( m_instance == NULL)
  { 
    m_instance = new T();
  }
  return m_instance;
}
 
template <class T>
T* singleton<T>::m_instance = NULL;

懒汉模式下,在定义m_instance变量时先等于NULL,在调用GetInstance()方法时,在判断是否要赋值。这种模式,并非是线程安全的,因为多个线程同时调用GetInstance()方法,就可能导致有产生多个实例。要实现线程安全,就必须加锁。

下面给出改进之后的代码

template <class T>
class singleton
{
protected:
    singleton(){};
private:
    singleton(const singleton&){};
    singleton& operator=(const singleton&){};
    static T* m_instance;
    static pthread_mutex_t mutex;
public:
    static T* GetInstance();
};
 
 
template <class T>
T* singleton<T>::GetInstance()
{
    pthread_mutex_lock(&mutex);
    if( m_instance == NULL)
    {
        m_instance = new T();
    }
    pthread_mutex_unlock(&mutex);
    return m_instance;
}
 
 
template <class T>
pthread_mutex_t singleton<T>::mutex = PTHREAD_MUTEX_INITIALIZER;
 
template <class T>
T* singleton<T>::m_instance = NULL;

 这一切看起来都很完美,但是程序猿是一种天生就不知道满足的动物。他们发现GetInstance()方法,每次进来都要加锁,会影响效率。然而这并不是必须的,于是又对GetInstance()方法进行改进

template <class T>
T* singleton<T>::GetInstance()
{
  if( m_instance == NULL)
  {
    pthread_mutex_lock(&mutex);
    if( m_instance == NULL)
    { 
       m_instance = new T();
    }
    pthread_mutex_unlock(&mutex);
  }
  return m_instance;
}

这也就是所谓的“双检锁”机制。但是有人质疑这种实现还是有问题,在执行 m_instance = new T()时,可能 类T还没有初始化完成,m_instance 就已经有值了。这样会导致另外一个调用GetInstance()方法的线程,获取到还未初始化完成的m_instance 指针,如果去使用它,会有意料不到的后果。其实,解决方法也很简单,用一个局部变量过渡下即可:

正解:

template <class T>
T* singleton<T>::GetInstance()
{
  if( m_instance == NULL)
  {
    pthread_mutex_lock(&mutex);
    if( m_instance == NULL)
    { 
       T* ptmp = new T();
       m_instance = ptmp;
    }
    pthread_mutex_unlock(&mutex);
  }
  return m_instance;
}

到这里在懒汉模式下,也就可以保证线程安全了。

然而,在linux下面还有另一种实现。linux提供了一个叫pthread_once()的函数,它保证在一个进程中,某个函数只被执行一次。下面是使用pthread_once实现的线程安全的懒汉单例模式

template <class T>
class singleton
{
protected:
  singleton(){};
private:
  singleton(const singleton&){};
  singleton& operator=(const singleton&){};
  static T* m_instance;
  static pthread_once_t m_once;
public:
  static void Init();
  static T* GetInstance();
};
 
 
template <class T>
void singleton<T>::Init()
{
  m_instance = new T();
}
 
template <class T>
T* singleton<T>::GetInstance()
{
  pthread_once(&m_once,Init);
  return m_instance;
}
 
template <class T>
pthread_once_t singleton<T>::m_once = PTHREAD_ONCE_INIT;
 
template <class T>
T* singleton<T>::m_instance = NULL;

 上面的单例类使用了模板,对每一种类型的变量都能实例化出唯一的一个实例。

例如要实例化一个int类型

int *p = singleton<int>::GetInstance()

例如要实例化一个string类型

string *p = singleton<string>::GetInstance()

在上面的实现中,在实例化对象时,调用GetInstance()函数时都没有传递参数,这是犹豫不同的对象其初始化时参数个数都不一样。如果要支持不同类型的对象带参数初始化,则需要重载GetInstance函数。然而在c++11中,已经支持了可变参数函数。这里给出一个简单的例子

#ifndef _SINGLETON_H_
#define _SINGLETON_H_
 
template <class T>
class singleton
{
protected:
  singleton(){};
private:
  singleton(const singleton&){};
  singleton& operator=(const singleton&){};
  static T* m_instance;
public:
  template <typename... Args>
  static T* GetInstance(Args&&... args)
  {
    if(m_instance == NULL)
      m_instance = new T(std::forward<Args>(args)...);
    return m_instance;
  }
 
 
  static void DestroyInstance()
  {
    if(m_instance )
      delete m_instance;
    m_instance = NULL;
  }
};
 
 
template <class T>
T* singleton<T>::m_instance = NULL;
 
#endif

测试函数

#include <iostream>
#include <string>
#include "singleton.h"
 
using namespace std;
struct A
{
  A(int a ,int b):_a(a),_b(b)
  {}
  int _a;
  int _b;
};
 
int main()
{
  int *p1 = singleton<int>::GetInstance(5);
  int *p2 = singleton<int>::GetInstance(10);
  cout << *p1 << " " << *p2 <<endl;
  string *p3 = singleton<string>::GetInstance("aa");
  string *p4 = singleton<string>::GetInstance("bb");
 
  cout << *p3 << " " << *p4 <<endl;
 
  A *p5 = singleton<A>::GetInstance(1,2);
 
  A *p6 = singleton<A>::GetInstance(4,5);
 
  cout << p5->_a << " " << p6->_a<<endl;
  return 0;
}
 

运行结果如下

以上所述是小编给大家介绍的C++实现线程安全的单例模式详解整合,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对呐喊教程网站的支持!

声明:本文内容来源于网络,版权归原作者所有,内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:notice#nhooo.com(发邮件时,请将#更换为@)进行举报,并提供相关证据,一经查实,本站将立刻删除涉嫌侵权内容。