1. 特殊类的设计

单例模式

设计模式是被反复使用多数人知晓经过分类的、代码设计经验的总结

单例模式：
一个类只能创建一个对象即单例模式，该模式可以保证系统中该类只有一个实例

单例模式分为饿汉模式和懒汉模式

饿汉模式

一开始就创建对象(main函数之前)

假设想要vector数组全局只有一份
所以进行限制，使之不能随意创建对象即将构造函数私有化

若想要创建对象，则通过公有的成员函数getinstallce创建
为了保证每次获取的都是同一个对象，就定义了一个静态的类类型的指针 _p
而静态的成员变量，需要在类外面初始化

在定义静态成员变量时创建对象

此时也可添加add增加和print打印的功能

定义私有的string数组 _v，使用其push_back 添加数据str，并使记录数字+1

扫描二维码关注公众号，回复： 15864269 查看本文章

使用print函数打印数据

由于getinstallce函数返回值是一个指针，所以需要使用->去访问add或者print函数

还可以通过设置锁进行多线程间的安全访问

设置私有锁

由于getinstallce函数返回值是一个静态的指针，所以无论是线程t1还是线程t2都可以访问到该函数
并通过该函数调用add或者 print函数
使用to_string 将任意类型转化为string

具体代码

饿汉模式
class stu
{
    
    
public:
	static stu* getinstallce()
	{
    
    
		return _p;
	}
	void add(const string& str)
	{
    
    
		_mtx.lock();//加锁
		_v.push_back(str);
		++_x;
		_mtx.unlock();//解锁
	}
	void print()
	{
    
    
		_mtx.lock();//加锁
		for (auto& e : _v)
		{
    
    
			cout << e << " ";
			cout << endl;
		}
		_mtx.unlock();//解锁
	}
private:
	//限制类外不能随意创建对象
	//构造函数私有化
	stu(int x=0)
		:_x(x)
	{
    
    
	}
private:
	mutex _mtx;
	int _x=0;
	vector<string>_v;
	static stu* _p;
};
//static成员变量在类外定义
stu* stu:: _p = new stu;


int main()
{
    
    
	int n = 10;
	thread t1([n]() {
    
    
		for (int i = 0; i < n; i++)
		{
    
    
			stu::getinstallce()->add("t1线程:"+to_string(i));
		}
		});
	thread t2([n]() {
    
    
		for (int i = 0; i < n; i++)
		{
    
    
			stu::getinstallce()->add("t2线程:" + to_string(2*i));
		}
		});
	t1.join();
	t2.join();
	stu::getinstallce()->print();
}
int main()
{
    
    
	stu::getinstallce()->add("张三");
	stu::getinstallce()->add("李四");
	stu::getinstallce()->print();//打印
	return 0;
}

懒汉模式

第一次访问实例对象时创建(第一次调用getinstallce函数时创建)

在饿汉模式的代码的基础上进行改造

在定义静态成员变量时设置为空

若_p指针为空，在创建对象，并返回
在调用getinstallce函数时才创建对象

虽然看似没有问题，但是在多线程下还存在线程安全的问题

定义一个静态锁，用于保护getinstallce函数中的实例对象

在初始化时，是不需要显示给值的

每次获取对象都要加锁解锁，但实际上只需要保证第一次即可

这样的写法依旧是不行的，当两个线程t1 t2同时进入if循环中，
当线程t1 new后解锁，线程t2获取锁，继续new，就会造成覆盖丢失数据

所以采用双检查加锁的方式

具体代码

//懒汉模式
class stu
{
    
    
public:
	static stu* getinstallce()
	{
    
    
		//双检查加锁
		if (_p == nullptr)
		{
    
    
			_imtx.lock();//加锁
			if (_p == nullptr)
			{
    
    
				_p = new stu;
			}
			_imtx.unlock();//解锁
		}
		return _p;
	}
	void add(const string& str)
	{
    
    
		_mtx.lock();//加锁
		_v.push_back(str);
		++_x;
		_mtx.unlock();//解锁
	}
	void print()
	{
    
    
		_mtx.lock();//加锁
		for (auto& e : _v)
		{
    
    
			cout << e << " ";
			cout << endl;
		}
		_mtx.unlock();//解锁
	}
	//特殊情况下释放单例对象
	static void delinstance()
	{
    
    
		_imtx.lock();
		if (_p)
		{
    
    
			delete _p;
			_p = nullptr;
		}
		_imtx.unlock();
	}
private:
	//限制类外不能随意创建对象
	//构造函数私有化
	stu(int x = 0)
		:_x(x)
	{
    
    
	}
	
	//防拷贝
	stu(const stu& s) = delete;
	stu& operator=(const stu& s) = delete;

private:
	static mutex _imtx;
	mutex _mtx;
	int _x = 0;
	vector<string>_v;
	static stu* _p;
};
//static成员变量在类外定义	 
stu* stu::_p = nullptr;
//将静态锁在类外初始化
mutex stu::_imtx;