首页 / C++ / C++实现线程安全的单例模式

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

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了C++实现线程安全的单例模式，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含3281字，纯文字阅读大概需要5分钟。

内容图文

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

首先给出饿汉模式的实现

template <class T>
class singleton
{
private:
    singleton(){};
    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>
T* singleton<T>::m_instance = new T();

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

下面来看懒汉模式

template <class T>
class singleton
{
private:
    singleton(){};
    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
{
private:
    singleton(){};
    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
{
private:
    singleton(){};
    singleton(const singleton&){};
    singleton& operator=(const singleton&){};
    static T* m_instance;
    static pthread_once_t m_once;
public:
    staticvoid Init();
    static T* GetInstance();
};


template <class T>
void singleton<T>::Init()
{
    m_instance = new T(100000);
}

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;

 

原文：http://www.cnblogs.com/myd620/p/6133420.html

内容总结

以上是互联网集市为您收集整理的C++实现线程安全的单例模式全部内容，希望文章能够帮你解决C++实现线程安全的单例模式所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1201166.html

来源：【匿名】