第21章单例模式

最新推荐文章于 2021-04-01 22:03:46 发布

weixin_30265171

最新推荐文章于 2021-04-01 22:03:46 发布

阅读量79

点赞数

文章标签： c/c++ 设计模式

原文链接：http://www.cnblogs.com/Manual-Linux/p/11101153.html

版权

一单例模式

单例模式，保障一个类仅有一个实例，并提供一个访问他的全局访问点
通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象，一个最好的办法是，让类自身负责保存它的唯一实例，这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法。

二注意：

使用单例模式，只能保证一个线程内对象不会被多次创建，而不能保证多线程的情况。因此，需要考虑多线程的话，就要用锁。

三 C++代码实现
在不考虑多线程时，单例模式实现的C++代码

// lesson2.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include <iostream>
using namespace std;



class Singleton
{
private:
    static Singleton* instance;
private:
    Singleton()  //构造方法让其private,这就堵死了外界利用new创建此类实例的可能
    {

    }
public:
    static Singleton* GetInstance()  //此方法是获得本类实例的唯一全局访问节点
    {
        if (instance == NULL)
        {
            instance = new Singleton();
        }
        return instance;
    }
};

Singleton* Singleton::instance = NULL;

int main()
{
    Singleton* s1 = Singleton::GetInstance();
    Singleton* s2 = Singleton::GetInstance();
    if (s1 == s2)  //比较两次实例化后对象的结果是实例相同
    {
        cout << "两个对象是相同的实例" << endl;
    }
    return 0;
}

上述代码：把类的构造方法改为私有，所有类都有构造方法，不编码则系统默认生成空的构造方法，若有显示定义的构造方法，默认的构造方法就会失效。这样对于外部代码，不能用new来实例化它，但是我们完全可以再写一个public方法，叫做GetInstance(),这个方法的目的就是返回一个实例，而在此方法中，去做是否有实例化的判断，如果没有实例化过，由调用private的构造方法new出这个实例，它可以调用是因为它们在同一个类中，private方法可以被调用。
多线程时的单例，使用双重锁定

#include "pch.h"
#include <iostream>
#include <WinSock2.h>
using namespace std;



class Singleton
{
private:
    static Singleton* instance;
    //临界区，防止多线程产生多个实例
    static CRITICAL_SECTION m_Sec;
private:
    Singleton()  //构造方法让其private,这就堵死了外界利用new创建此类实例的可能
    {

    }
public:
    static CRITICAL_SECTION* getlock()
    {
        return &m_Sec;
    }
    static Singleton* GetInstance()  //此方法是获得本类实例的唯一全局访问节点
    {
        //双重锁定
        if (NULL == instance)
        {
            EnterCriticalSection(&m_Sec);
            if (instance == NULL)
            {
                instance = new Singleton();
            }
            LeaveCriticalSection(&m_Sec);
        }
        return instance;
    }
};

Singleton* Singleton::instance = NULL;
CRITICAL_SECTION Singleton::m_Sec = CRITICAL_SECTION();

int main()
{
    //初始化临界区
    InitializeCriticalSection(Singleton::getlock());
    
    Singleton* s1 = Singleton::GetInstance();
    Singleton* s2 = Singleton::GetInstance();

    //删除临界区
    DeleteCriticalSection(Singleton::getlock());

    if (s1 == s2)  //比较两次实例化后对象的结果是实例相同
    {
        cout << "两个对象是相同的实例" << endl;
    }
    return 0;
}

使用双重锁的原因：
当instance为NULL并且同时有两个线程调用GetInstance()方法时，他们都将通过第一层的if(NULL == instance)的判断，然后由于lock机制，这两个线程则只有一个进入，另一个在外排队等候，必须要其中一个进入并出来后，另一个才能进入。而此时如果没有了第二重的instance是否为null的判断，则第一个线程创建了实例，而第二个线程还可以继续再创建新的实例，就达不到单例的目的了。

四以下是一些拓展

缓存与单例

//本例回避多线程的安全问题
#include "pch.h"
#include <iostream>
#include <map>
#include <string>
using namespace std;

class Singleton;
static map<string, Singleton*> myMap = map<string, Singleton*>();

//懒汉 延时加载
class Singleton
{
private:
    Singleton()
    {
        m_singer = NULL;
        cout << "单例正在构建" << endl;
    }
public:
    static Singleton* GetInstance()
    {
        if (myMap.find(DEFAULT_KEY) != myMap.end())
        {
            return myMap.find(DEFAULT_KEY)->second;
        }
        if (m_singer == NULL)
        {
            m_singer = new Singleton;
            myMap[DEFAULT_KEY] = m_singer;
        }
        return m_singer;
    }
private:
    static Singleton *m_singer;
    static string DEFAULT_KEY;
};

Singleton* Singleton::m_singer = NULL;
string Singleton::DEFAULT_KEY = "ONE";

int main()
{
    Singleton *p1 = Singleton::GetInstance();
    Singleton *p2 = Singleton::GetInstance();
    cout << hex << p1 << ' ' << hex << p2 << endl;
    system("pause");
    return 0;
}

多例拓展

#include "pch.h"
#include <iostream>
#include <map>
#include <string>
using namespace std;
//单例模式和map配合,构成缓存的形式
//缓存的实例个数
const static int NUM_MAX = 5;

class Singleton;
static map<int, Singleton*> myMap = map<int, Singleton*>();  //int用来控制数列

class Singleton
{
private:
    Singleton()
    {
        m_singer = NULL;
        cout << "正在构建Singleton" << endl;
    }
public:
    static Singleton* GetInstance()
    {
        m_singer = myMap[m_InstanceCount];
    
        if (m_singer == NULL)
        {
            m_singer = new Singleton;
            myMap[m_InstanceCount] = m_singer;
        }
        if (m_InstanceCount > NUM_MAX) 
        {
            m_InstanceCount = 1;
        }
        return m_singer;

        m_InstanceCount++;

    }
private:
    static Singleton* m_singer;
    static int m_InstanceCount;  //存放实例的个数
};

Singleton *Singleton::m_singer = NULL;
int Singleton::m_InstanceCount = 1;//初始化的实例个数

int main()
{
    Singleton* p1 = Singleton::GetInstance();
    Singleton* p2 = Singleton::GetInstance();
    Singleton* p3 = Singleton::GetInstance();
    Singleton* p4 = Singleton::GetInstance();
    Singleton* p5 = Singleton::GetInstance();
    printf("p1=%x,p2=%x,p3=%x,p4=%x,p5=%x\n", p1, p2, p3, p4, p5);
    Singleton* p6 = Singleton::GetInstance();
    Singleton* p7 = Singleton::GetInstance();
    Singleton* p8 = Singleton::GetInstance();
    Singleton* p9 = Singleton::GetInstance();
    Singleton* p10 = Singleton::GetInstance();
    printf("p6=%x,p7=%x,p8=%x,p9=%x,p10=%x\n", p6, p7, p8, p9, p10);
    system("pause");
    return 0;
}

参考资料：
1 《大话设计模式》
2 https://blog.csdn.net/xiqingnian/article/details/41833033 大话设计模式C++实现-第21章-单例模式

转载于:https://www.cnblogs.com/Manual-Linux/p/11101153.html