C++11的多线程并发编程（五）

C++11的多线程并发编程（四）

继续记录锁的一些概念，眼瞅着疫情的拐点即将出现了。

1. unique_lock
   unique_lock这个是可以取代前一篇写的lock_guard，在第二个参数的为adopt_lock时与之前一样，表示unique_lock对象已经绑定了互斥量，提前lock互斥量，不用自己去unlock了，其实不建议搞这些花里胡哨的，lock和unlock对称使用貌似还清楚一点。

使用方法就是直接将lock_guard换成unique_lock

#include <iostream>
#include <thread>
#include <list>
#include <mutex>

using namespace std;

class A
{
public:
	void inCommand()
	{
		for(int i = 0; i < 1000; i++)
		{
			lock(mylock1,mylock2);
			lock_guard<mutex> myguard1(mylock1,adopt_lock);
			lock_guard<mutex> myguard2(mylock2,adopt_lock);
		//	mylock.lock();
			ticket.push_back(i);
			cout << "a command is comming" << endl;
		//	mylock.unlock();
		}
	}
	
	void outCommand()
	{
		for(int j = 0; j < 1000; j++)
		{
			lock(mylock1,mylock2);
			unique_lock<mutex> myguard1(mylock1,adopt_lock);
			unique_lock<mutex> myguard2(mylock2,adopt_lock);
			//	mylock.lock();
			if(!ticket.empty())
			{
				int command = ticket.front();
				ticket.pop_front();	
				cout << "command is :" << command << endl;
			//	mylock.unlock();
			}
			else
			{
				cout << "there is no people" << endl;	
			//	mylock.unlock();
			}
		}
		
	}
	
private:
	list<int> ticket;
	mutex mylock1;
	mutex mylock2;
};

int main(int argc, char *argv[])
{
	A a;
	thread thread1(&A::inCommand, &a);
	thread thread2(&A::outCommand, &a);
	thread1.join();
	thread2.join();

	cout << "the main thread is end;" << endl;
	return 0;
}

完全替换那要他有何用，存在即合理，设想一下，线程一拿到锁后要执行好长一段时间，线程二在等这个锁，难道他就这么一直等下去么，所以unique_lock的作用就体现出来，
try_to_lock参数，表示尝试去锁，如果没有锁定成功那么就可以去执行别的程序，并不会一直处于等待状态。
代码的写法如图所示：

unique_lock<mutex> myunique(mymutex, try_to_lock);
if(myunique.own_lock())
{
	//获得了锁的权利
	ticket.push_back(i);
	//其他处理代码
}
else
{
	//没拿到锁
	cout << "消息收集函数在执行，却没有获得锁的权利执行与共享数据无关的程序"<< i << endl;
}

defer_lock参数，这个参数就是表示初始化了一个没有加锁的mutex，需要自己加锁，互斥量的解锁，到生命周期结束后自动结束。或者自己中途解锁也行。

2 成员函数release（）；
返回指向mutex指针，并解除对象与mutex的绑定，并通过指针进行调用解锁函数。
使用方法如图所示：

unique_lock<mutex> myunique(mymutex, try_to_lock);
//定义一个该类型指针
mutex *ptx = myunique.release();

ticket.push_back(i);

ptx->unlock();

或者通过移动语义move换个对象绑定
例如：

unique_lock<mutex> myunique(mymutex);
unique_lock<mutex> myunique2(move(myunique));
//定义一个指针
mutex *ptx = myunique2.release();

ticket.push_back(i);

ptx->unlock();

3.锁的粒度
这个是一个概念，锁住的代码少，那么锁的粒度就细，执行效率就越高
锁住的代码多，那么锁的粒度就粗，执行效率就越低，根据情况选择适合的粒度，当然了，这概念我也只是听到，没有实际的体验，先记下再说。

4. 单例模式
   这里顺便记录一下单例模式，之前一直模模糊糊不太懂，面试基本这个问题回答不上来。
   单例模式：在整个任务中，有一些特殊的类，在程序里只能创建一个对象，
   先放上代码：

```cpp
#include<iostream>

using namespace std;

class myClass
{
private:
	myClass(){};
private:
	static myClass *myPtr;
public:
	static myClass *getInstance()
	{
		if(myPtr == NULL)
		{
			myPtr = new myClass();
		}
		return myPtr;
	}
	void myPrint()
	{
		cout << "hello comedy" << endl;
	}
};

myClass *myClass::myPtr = NULL;
int main(int argv, char *argc[])
{
	myClass *myptr1 = myClass::getInstance();
	myClass *myptr2 = myClass::getInstance();
	myptr1->myPrint();
	myptr2->myPrint();
	cout << " main thread end" << endl;
	return 0;
}

运行结果如图所示：

构造函数的私有化，防止新建多个对象，指针所指向的对象唯一，并且静态表示不属于任何一个对象，属于类。此时代码的myptr1和myptr2所指向的地址是一个地址。
但这里你会发现两个问题，
一：new和delete是成对出现的，这个程序就不完美。
二：如果是两个线程进行new 对象，那么会出现线程一未完成new对象，进行到一半，而时间片转到线程二时，此时他又可以new一个，因为线程一未完全结束new对象，这样的话程序就可以产生两个new对象了，不符合单例模式的要求，因此借鉴案例分别引入
类中类，创建对象，然后推出程序的时候自动执行析构函数，函数中添加delete指针和互斥量的方法，线程进行加锁的方式进行互斥访问。
方法如图所示：

#include<iostream>
#include<mutex>
#include<thread>
using namespace std;

mutex mymutex;
class myClass
{
private:
	myClass(){};
private:
	static myClass *myPtr;
public:
	static myClass *getInstance()
	{
		if(myPtr == NULL)
		{
			unique_lock<mutex> mylock(mymutex);
			if(myPtr == NULL)
			{
				myPtr = new myClass();
				static delClass mydelclass;
			}
		}
			return myPtr;
	}
	class delClass
	{
	public:
		~delClass()
		{
			if(myPtr != NULL)
			{
				delete myPtr;
				cout << "delete myPtr" << endl;
			}
		}
	};
	void myPrint()
	{
		cout << "hello comedy" << endl;
	}
};

myClass *myClass::myPtr = NULL;

void myFunc()
{
	myClass *myptr1 = myClass::getInstance();
	myptr1->myPrint();
	cout << "hello yan" << endl;
}

int main(int argv, char *argc[])
{
	thread t1(myFunc);
	thread t2(myFunc);
	t1.join();
	t2.join();
	cout << " main thread end" << endl;
	return 0;
}

运行结果显示，正确无异常，且在程序退出后显示delete指针。

5. call_once
   后来了解到，c++11提供了一个函数call_once()；可以代替这个只执行一次的new对象这个操作，以及增加参数互斥标志，就是全给你搞好了。

#include<iostream>
#include<mutex>
#include<thread>
using namespace std;

mutex mymutex;
once_flag myFlag;

class myClass
{
private:
	myClass(){};
private:
	static myClass *myPtr;
public:
	static void singleCreate()
	{
		myPtr = new myClass();
		static delClass mydelclass;	
	}
	static myClass *getInstance()
	{
		call_once(myFlag, singleCreate);
	//	if(myPtr == NULL)
	//	{
	//		unique_lock<mutex> mylock(mymutex);
	//		if(myPtr == NULL)
	//		{
	//			myPtr = new myClass();
	//			static delClass mydelclass;
	//		}
	//	}
			return myPtr;
	}
	class delClass
	{
	public:
		~delClass()
		{
			delete myPtr;
			cout << "delete myPtr" << endl;
		}
	};
	void myPrint()
	{
		cout << "hello comedy" << endl;
	}
};

myClass *myClass::myPtr = NULL;

void myFunc()
{
	myClass *myptr1 = myClass::getInstance();
	myptr1->myPrint();
	cout << "hello yan" << endl;
}

int main(int argv, char *argc[])
{
	thread t1(myFunc);
	thread t2(myFunc);
	t1.join();
	t2.join();
	cout << " main thread end" << endl;
	return 0;
}

可以看到，结果与上述代码一样，可以单换。

留一个问题算了，getInstance为啥是指针返回，不是引用返回和值返回