多线程04：互斥量和死锁

????互斥量和死锁

一、数据共享问题

首先，我们看看多线程的执行顺序：

网站设计、成都网站建设的开发，更需要了解用户，从用户角度来建设网站，获得较好的用户体验。创新互联多年互联网经验，见的多，沟通容易、能帮助客户提出的运营建议。作为成都一家网络公司，打造的就是网站建设产品直销的概念。选择创新互联，不只是建站，我们把建站作为产品，不断的更新、完善，让每位来访用户感受到浩方产品的价值服务。

void TextThread() {
	cout << "我是线程：" << this_thread::get_id() << endl;
	//线程内操作代码
	cout << "线程" << this_thread::get_id() << "操作结束" << endl;
}

int main()
{
	vector threadVec;
	for (int i = 0; i < 5; ++i) {
		threadVec.push_back(thread(TextThread));
	}
	for (int i = 0; i < 5; ++i) {
		threadVec[i].join();
	}
	return 0;
}

把thread对象放入到容器中管理，看起来像个thread对象数组，对一次创建大量的线程并对大量线程进行管理有好处；
多个线程执行顺序是乱的，跟操作系统内部对线程的运行调度机制有关；

然而上述的线程中并没有涉及到线程之间的通信问题，如果涉及多个线程操作同一堆数据，会怎么样呢？（学过操作系统都知道，这就是数据共享问题）

如果是线程只读数据，是安全稳定的，不会存在问题；
如果是有读有写：①不加处理就会执行出错，如对同一个数据同时读和写，比如简单的一个++i，底层是三四条汇编代码，运行过程中（还没有执行完++i操作）线程就被调度了，而其他线程又用这个i值，又++i，导致值错乱！；②最简单的防止崩溃方法：读的时候不能写，写的时候不能读。

二、互斥量

2.1 互斥量的基本概念

c++中互斥量就是个类对象，可以理解为一把锁，多个线程尝试用lock()成员函数来加锁，只有一个线程能锁定成功，如果没有锁成功，那么流程将卡在lock()这里不断尝试去锁定。
互斥量使用要小心，保护数据不要多也不要少，少了达不到效果，多了影响效率。

2.2 互斥量的用法

头文件包含#include

最基础用法

①lock()、unlock()

步骤：1.lock()； 2.操作共享数据；3.unlock();

lock()和unlock()要成对使用，注意这种情况：

//拿取数据的函数
bool outMsgPro(int& command) {

	myMutex.lock();
	if (!msgRecvQueue.empty()) {//非空就进行操作
		int command = msgRecvQueue.front();
		msgRecvQueue.pop();
		//因为进入这里也会return了，一定要unlock();
		myMutex.unlock();
		return true;
	}
	myMutex.unlock();
    //其他操作代码
	return false;
}

高级一点的写法

②lock_guard类模板

lock_guard myGuard(myMutex)直接取代了myMutex.lock()和myMutex.unlock();
lock_guard构造函数执行了mutex::lock();在出作用域，调用析构函数时，执行mutex::unlock()
可以加上{}，约束lock_guard的作用域；

//拿取数据的函数
bool outMsgPro(int& command) {
    
    {
		std::lock_guard myGuard(myMutex);
		if (!msgRecvQueue.empty()) {//非空就进行操作
			int command = msgRecvQueue.front();
			msgRecvQueue.pop();
			return true;
		}
    }
     //其他操作代码
	return false;
}

三、死锁

3.1 死锁演示

产生死锁的条件：至少有两个互斥量，多个线程同时需要这两个互斥量，最终形成闭环。比如：

a. 线程A执行时，这个线程先锁mutex1，并且锁成功了，然后去锁mutex2的时候，出现了上下文切换。
b. 线程B执行，这个线程先锁mutex2，因为mutex2没有被锁，即mutex2可以被锁成功，然后线程B要去锁mutex1.
c. 此时，死锁产生了，A锁着mutex1，需要锁mutex2，B锁着mutex2，需要锁mutex1，形成闭环，没法继续运行。

3.2 死锁解决方案

只要保证多个互斥量上锁的顺序一样就不会造成死锁！

3.3 std::lock()函数模板

std::lock(mutex1,mutex2……)：一次锁定多个互斥量（一般这种情况很少），用于处理多个互斥量。但是锁要单独解开mutex1.unlock(),mutex2.unlock()都要自己写
该函数：如果互斥量中一个都没锁住，它就等着，等所有互斥量都锁住，才能继续执行。如果有一个没锁住，就会把已经锁住的释放掉（即要么互斥量都锁住，要么都没锁住，自动防止死锁）

3.4 std::lock_guard和std::adopt_lock参数

```
std::lock(mutex1,mutex2);
lock_guard myGuard1(mutex1, adopt_lock);
lock_guard myGuard2(mutex2, adopt_lock);
```
用lock_guard构造mutex1、mutex2锁的对象，加入adopt_lock后，在调用lock_guard的构造函数时，不再进行lock(); 但是在出了对象的作用域后，还是会调用unlock()释放锁！解决了lock多个锁后需要自己每个释放的问题。
std::adopt_lock为结构体对象，起一个标记作用，表示这个互斥量已经lock()，不需要再lock()操作。

整个示例代码：

class A
{
public:
	//拿取数据的函数
	bool outMsgPro(int& command) {

		lock(mutex1, mutex2);
		lock_guard myGuard1(mutex1, adopt_lock);
		lock_guard myGuard2(mutex2, adopt_lock);
        //②lock_guard myGuard1(mutex1); lock_guard myGuard2(mutex2);
		//①mutex1.lock(); mutex2.lock();
		if (!msgRecvQueue.empty()) {//非空就进行操作
			command = msgRecvQueue.front();
			msgRecvQueue.pop();
			//因为进入这里也会return了，一定要unlock();
			//mutex1.unlock(); mutex2.unlock();
			
			return true;
		}
		//mutex1.unlock(); mutex2.unlock();
		return false; //return自动释放锁
	}
	//写入数据函数；
	void inMsgPro() {

		for (int i = 0; i < 100; ++i) {
			cout << "inMsgPro()执行，插入元素" << i << endl;

			lock(mutex1, mutex2);
			lock_guard myGuard1(mutex1, adopt_lock);
			lock_guard myGuard2(mutex2, adopt_lock);
            //②lock_guard myGuard1(mutex1); lock_guard myGuard2(mutex2);
			//①mutex1.lock(); mutex2.lock();
			msgRecvQueue.push(i);
			//mutex1.unlock(); mutex2.unlock();
		}
	}
	//测试拿出数据函数
	void Test() {
		int data;
		for (int i = 0; i < 100; ++i) {
			if (outMsgPro(data)) cout << data << " ";
			else cout << "没有数据" << " ";
		}
	}
private:
	queue msgRecvQueue;
	mutex mutex1;
	mutex mutex2;
};


int main() {
	A a;
	thread myInMsgObj(&A::inMsgPro, &a);//必须要传入地址，说明是同一个元素
	thread myOutMsgObj(&A::Test, &a);
	myInMsgObj.join();
	myOutMsgObj.join();	
	return 0;
}

文章题目：多线程04：互斥量和死锁
链接地址：http://hbruida.cn/article/dsoipge.html