C++单例模式

最新推荐文章于 2024-05-17 13:43:49 发布

Prozzz777

最新推荐文章于 2024-05-17 13:43:49 发布

阅读量205

点赞数

分类专栏： C++

本文链接：https://blog.csdn.net/qq_29689907/article/details/85056238

版权

C++ 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

什么是单例模式:
单例模式就是一个类只能实例化一次，即只能有一个实例化的对象的类

怎么创建一个单例模式的类：
先看下面的例子：

class Car
{
public:
	Car() {}
	~Car() {}
};
void main()
{
	Car c1;
	Car *pc2 = new Car;
}

显然上面的例子的类可有很多实例，要禁止多实例，如果把构造函数私有化，能不能行得通呢？

class CSingleton
{
private:
	CSingleton() {}
};
void main()
{
	CSingleton cs1;
	CSingleton *pcs2 = new CSingleton ;
}

很显然，编译器报错，因为当构造函数是private或者protected时，构造函数将无法从外部调用。

既然构造函数私有了，我们可以通过一个公有的方法调用该构造函数，供外部使用。要求这个公有方法返回一个对象，为保证多次调用这个函数都返回的是同一个对象，我们可以把类内部返回的对象设置成静态的，代码如下：

class CSingleton
{
private:
	CSingleton() {}
	static CSingleton*p;
public:
	static CSingleton* GetCSingletonInstance()
	{
		if (p == nullptr)
		{
			p = new CSingleton;
		}
		return p;
	}

};
CSingleton * CSingleton::p = NULL;

void main()
{	
	CSingleton *pcs1=CSingleton::GetCSingletonInstance();
	CSingleleton *pcs2 = CSingleton::GetCSingletonInstance();
	cout << pcs1 << endl;
	cout << pcs2 << endl;
}

运行结果：
在这里插入图片描述

两个地址是一样，证明我们的单例类的设计正确的，原理其实很简单，第一次调用获取实例的函数时，静态类的变量指针空，所以会创建一个对象出来，第二次调用就不是空了，直接返回第一次的对象指针（地址），这样就间接完成一个类只有一个实例。

上面的方法仅限于单线程工作正常，但是在多线程时就可能出问题了。假设两个线程同时运行到判断p是否为空的if语句，并且p确实没有创建，那么两个线程都会创建一个实例，这和我们想要的相违背了。这是我们毫不犹豫想到的是加个锁：

#include <iostream>
#include <thread>
#include <mutex>
#include<windows.h>
using namespace std;

class CSingleton
{
private:
	CSingleton() {}
	static CSingleton*p;
public:
	static mutex mtx;
	static CSingleton* GetCSingletonInstance()
	{
		if (p == nullptr)
		{
			mtx.lock();
			p = new CSingleton;
			mtx.unlock();
		}
		return p;
	}

};
CSingleton * CSingleton::p = NULL;
mutex CSingleton::mtx;

void fun1(int n)
{
	while (n>0)
	{
		CSingleton *pt = CSingleton::GetCSingletonInstance();
		cout << "fun1 " << "pt addr:" << pt << endl;
		Sleep(100);	 
		n--;
	}
}
void fun2(int n)
{
	while (n>0)
	{
		CSingleton *pt = CSingleton::GetCSingletonInstance();
		cout << "fun2 " << "pt addr:" << pt << endl;
		Sleep(100);
		n--;
	}
}

void main()
{
	thread t1 (fun1,5);
	thread t2 (fun2,10);
	t1.join();
	t2.join();
}

运行结果如下图：两个线程都去实例化这个类，结果都只是同一个实例。
在这里插入图片描述

总结一下我们的这种实现单例模式的方式：类中声明一个静态的本类指针，再写一个public的函数来让这个指针指向我们新创建的实例，返回这个指针（这个实例的地址），并进行加锁，这个对象就永远只有一份，然后单例模式就实现了。

class CSingleton
{
private:
	CSingleton() {}
public:
	static mutex mtx;
	static CSingleton* GetCSingletonInstance()
	{
		mtx.lock();
		static CSingleton obj;
		mtx.unlock();
		return &obj;
	}
};
mutex CSingleton::mtx;

也可以像上面的代码一样把静态对象放到函数里，这样就省去了外部声明，只要返回一个静态的类地址，就算这个函数执行完也不会销毁，它被保存在静态区和全局变量差不多。

再次总结：只要返回一个本类对象的地址就好了，这个地址要是静态的。别忘记加锁。

而且上面这种方式也被人们成为懒汉模式，为什么叫懒汉？因为这样的方式只有在我调用 CSingleton::getInstance(); 的时候才会返回一个实例化的对象，懒死了，我不要你你就不给我，是不是？

下面这种方式就和上面的不同，人家还没要，我就忍不住先给人家准备好了，如饥似渴，所以也叫饿汉模式。

我们注意到上面第一种方式，类中的静态变量要先被外部声明，否则编译器不会为它分配空间，像这样 CSingleton* CSingleton::p = NULL; 其实我们可以在这一步就new一个对象出来，因为p是CSingleton的成员，它是可以调用构造函数的哦，于是我们改成这样就是饿汉模式了

class CSingleton
{
private:
    CSingleton()
    {
    }
    static CSingleton *p;
public:
    static CSingleton* getInstance()
    {
        return p;
    }
};
CSingleton* CSingleton::p = new CSingleton();