确保对象的唯一性 - 单例模式

最新推荐文章于 2025-12-16 20:04:55 发布

原创最新推荐文章于 2025-12-16 20:04:55 发布 · 531 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式 #单例设计模式

设计模式(C++实现) 专栏收录该内容

4 篇文章

订阅专栏

本文详细介绍了单例模式的概念、作用以及在C++中的实现方式，包括简单的单例模式、饿汉式单例模式和使用互斥锁的单例模式。通过实例分析了多线程环境下可能遇到的问题及解决方案，帮助读者掌握如何确保对象的唯一性并优化性能。

单例模式在我们的日常开发中用的非常多，单例模式最大的特点就是只能生成一个类对象。
比方配置文件的类信息，就可以使用单例模式实现，因为配置文件是固定的，不论在代码的哪个位置获取配置项信息，得到的都应该是相同的信息。

既然只能生成一个类对象，那么我们就得考虑下如何实现这个只生成一个对象，在C++中我们知道，当定义或new一个对象时，就会调用构造函数，构造函数的执行成功，才宣誓一个对象的诞生完成。也就是说构造函数的调用是随着对象的定义而发生的，所以要确保只能生成一个对象，就要是的构造函数不可随意调用。
C++里，私有属性的成员函数或变量是不能被外部直接调用的，所以为了限制构造函数的调用，我们可以将构造函数设为私有，
取而代之的是定义一个公有的static静态函数与一个私有static静态类对象变量来实现单例模式。代码如下：

#include <iostream>
#include <string.h>
#include <stdio.h>

using namespace std;

class SigalMode
{
private:
    static SigalMode* m_pInstance;
    static int m_count;

    SigalMode()
    {
        cout << "SigalMode()" << endl;
        m_count++;
    }
    SigalMode(const SigalMode& obj);
    SigalMode& operator = (const SigalMode& obj);
public:

    static SigalMode* getInstance()  //单例模式主要代码块
    {
        if(NULL == m_pInstance)
        {
            m_pInstance = new SigalMode;
        }
        return m_pInstance;
    }

    int getCount()
    {
        return m_count;
    }

    ~SigalMode()
    {
        delete m_pInstance;
    }

};
int SigalMode::m_count = 0;
SigalMode* SigalMode::m_pInstance = NULL;

int main(int argc, char* argv[])
{
    cout << SigalMode::getInstance()->getCount() << endl;
    cout << SigalMode::getInstance()->getCount() << endl;
    cout << SigalMode::getInstance()->getCount() << endl;

    return 0;
}

编译执行：

从输出看到，我们调用的了三次GetInstance函数，但是构造函数只调用了一次，说明这个后两次GetInstance不调用构造函数，直接使用的是第一个GetInstance得到的类对象，这就是单例模式的简单实现。

对于上边的单例模式，可以应对大部分的场景，但是还不够，假如我们多线程使用同一个单例，那么在GetIstance函数里就有可能出现：A线程判判断m_pInstance为NULL，进行new操作，由与A线程还未new完成，此时B线程执行到这步，也会得到m_pInstance为NULL，从而B线程也会进行new操作，那么此时A、B线程操作的就不是同一个对象。

    对于多线程引发的问题，我们可以按如下两种方式解决：
    第一种方式：在类定义是就将单例对象实例化(饿汉式单例模式)
    第二种方式：使用互斥锁

先来看第一种方式：类定时时单例对象实例化，也就是说在类定义完成时，我们的单例对象就已经产生了

#include <iostream>
#include <string.h>
#include <errno.h>
#include <stdio.h>

using namespace std;

class SigalMode
{
private:
    static SigalMode* m_pInstance;
    static int m_count;

    SigalMode()
    {
        cout << "SigalMode()" << endl;
        m_count++;
    }
    SigalMode(const SigalMode& obj);
    SigalMode& operator = (const SigalMode& obj);
public:

    static SigalMode* getInstance()
    {
        return m_pInstance; //直接返回实例化后的对象
    }

    int getCount()
    {
        return m_count;
    }

    ~SigalMode()
    {
        delete m_pInstance;
    }

};
int SigalMode::m_count = 0;
SigalMode* SigalMode::m_pInstance = new SigalMode; //实例化单例对象



int main(int argc, char* argv[])
{

    cout << SigalMode::getInstance()->getCount() << endl;
    cout << SigalMode::getInstance()->getCount() << endl;
    cout << SigalMode::getInstance()->getCount() << endl;

    return 0;
}

编译执行

第一种方式虽然能够解决问题，但是代价是无论是不是用单例对象，这个对象从一开始就被创建，某种程度来说，浪费了内存空间。

第二种方式互斥锁：
使用互斥锁，主要点就是在GetInstance函数里把代码锁住，下边只给出这部分的代码，其余代码都一样

    static SigalMode* getInstance()
    {
        pthread_mutex_lock(&mutex_lock); //加锁
        if(NULL == m_pInstance)
        {
            m_pInstance = new SigalMode;
        }
        pthread_mutex_unlock(&mutex_lock); //解锁
        return m_pInstance;       
    }

这么使用锁之后，问题就可以解决了，但是还是有点问题，单例模式中，只需要调用一次new，后边就不需要new了，但是多线程使用时每次都需要等待锁的释放，这影响了执行效率。下边来看另外一种加使用锁的方式(使用双重锁)：

static SigalMode* getInstance()
{
    if(NULL == m_pInstance)
    {
        pthread_mutex_lock(&mutex_lock);
        if(NULL == m_pInstance)
        {
            m_pInstance = new SigalMode;
        }
        pthread_mutex_unlock(&mutex_lock);
    }
    return m_pInstance;       
}

以上几种单例模式的实现方式，可根据具体情况具体选择。