笔记：C++多线程编程(3)

互斥量，死锁等概念

数据共享问题分析：
1.只读数据
安全，稳定，不需要什么特别的处理
2.有读有写数据
需要特别的处理，否则，容易崩溃
最简单的处理办法：读的时候不能读/写，写的时候不能读/写
（因为我们不清楚各个线程之间的关系，为了稳定，避免一切读写）
先举一个可能崩溃的例子，见如下程序：
是一个读线程，写线程并行处理一个公共list数据的程序

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

using namespace std;

class A
{
public:
	void data_w()
	{
		
		for (int i = 0; i < 10000; ++i)
		{
			cout << "This process push in a number\n" << i << endl;
			data.push_back(i);
		}
	}

	void data_r()
	{
		for (int i = 0; i < 10000; ++i)
		{
			if (data.empty())
			{
				cout << "The list is empty\n";
			}
			else
			{
				int temp = data.front();
				data.pop_front();
				cout << "We get a number " << temp << endl;
			}
		}
	}

private:
	std::list<int> data;
};

int main()
{
	A a;
	
	std::thread pro2(&A::data_w, &a);
	std::thread pro1(&A::data_r,&a);
	pro2.join();				
	pro1.join();
	//这里报错是真滴玄学，有时候居然能正常执行完
	cout << "Main process is finished\n";
	return 0;
}

那么怎么实现上述的解决办法呢？
我们先引入几个基本概念
一、互斥量(mutex)
互斥量是一个类对象，像是一把锁，多个线程尝试用lock()方法来加锁，如果成功，会返回锁住；如果不成功，线程会卡住，直到成功锁住
注意：锁住的内容多了，影响程序效率；少了，没有达到效果，需要刚刚好
1.lock()和unlock()的用法
头文件：

#include <mutex>

使用办法：
先lock()，操作共享数据，然后unlock() //实际上锁住的是共享数据
注：这一对函数成对出现，即锁住后必定解锁

具体的代码示例

std::mutex mymut;

mymut.lock()
//共享数据操作段
mymut.unlock() 

2.std::lock_guard()类模板
它可以直接取代lock()和unlock()，即有了这个类模板，这两个方法都用不了了
具体用法

std::lock_guard<std::mutex> myguard (mymutex)
//共享数据操作段
//保护部分覆盖整个作用域

对于lock_guard()我们可以这样理解：
这个类的构造器中调用了lock()方法，而在析构器中调用了unlock()方法，因此其保护的范围是从声明开始，到作用域边界调用析构函数结束。
于是我们有以下操作，这样就能够更灵活地调用这个类模板

//其他不需要保护的语句
{
std::lock_guard<std::mutex> myguard (mymutex)
//共享数据操作段
//保护部分覆盖整个作用域
}
//其他不需要保护的语句

二、死锁
（至少有两个互斥量才会产生）
举例说明：
有两个线程1和2，有两个互斥量（锁）A和B
线程1先上了A锁，然后准备上B锁，但此时由于线程间的切换，B锁没上，直接切到了线程2，然后线程2先上B锁，之后准备上A锁，这时候发现A锁已经给了线程1，于是两者大眼瞪小眼，程序无法继续进行。这种情况称为死锁（实际上就是互锁）
下面举例说明：

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

using namespace std;

//一些说明：
//std::lock_guard<std::mutex> my_guard(my_mut);
//这是一个类模板，生成了一个my_guard的类，在初始化时需要给这个类一个定义好的mutex类
//并且这个类的构造器中调用了lock()方法，而在析构器中调用了unlock()方法。
class A
{
public:
	void data_w()
	{
		
		for (int i = 0; i < 10000; ++i)
		{
			std::lock_guard<std::mutex> my_guard2(my_mut2);
			std::lock_guard<std::mutex> my_guard1(my_mut1);
			//my_mut.lock();
			cout << "This process push in a number\n" << i << endl;
			data.push_back(i);
			//my_mut.unlock();
		}
	}

	void data_r()
	{
		for (int i = 0; i < 10000; ++i)
		{
			std::lock_guard<std::mutex> my_guard1(my_mut1);
			std::lock_guard<std::mutex> my_guard2(my_mut2);
			//my_mut.lock();
			if (data.empty())
			{
				cout << "The list is empty\n";
				//my_mut.unlock();
			}
			else
			{
				int temp = data.front();
				data.pop_front();
				cout << "We get a number " << temp << endl;
				//my_mut.unlock();
			}
		}
	}

private:
	std::list<int> data;
	mutex my_mut1;
	mutex my_mut2;
};

int main()
{
	A a;
	
	std::thread pro2(&A::data_w, &a);
	std::thread pro1(&A::data_r,&a);
	pro2.join();				
	pro1.join();

	std::cout << "Main process is finished\n";
	return 0;
}

运行一下，发现程序直接卡住不动了