C++多线程安全

1.互斥量(mutex)

用代码把共享数据锁住，其他尝试操作共享数据的线程必须等待 锁定->操作->解锁

头文件#include<mutex>

lock()   unlock()是mutex的成员函数，成对使用，有lock必然要有unlock

using namespace std;
class A {
public:
	//收到数据，塞进容器中
	void inMsgRecList() {
		for (int i = 0;i < 100000;i++) {
			cout << "inMsgRecList插入一个元素" << i << endl;
			my_mutex.lock();
			msgRecList.push_back(i);
			my_mutex.unlock();
		}
	}
	//从容其中取出数据
	void outMsgRecList() {
		for (int i = 0;i < 100000;i++) {
			my_mutex.lock();
			if (!msgRecList.empty()) {
				int msg = msgRecList.front();
				msgRecList.pop_front();
				my_mutex.unlock();
			}
			else {
				cout << "outMsgRecList执行，但List中为空" << endl;
				my_mutex.unlock();
			}
		}
		cout << "执行完了" << endl;
	}
private:
	list<int> msgRecList;
	mutex my_mutex;
};

int main() {
	A myobj;
	thread myOutthread(&A::outMsgRecList,&myobj);
	thread myInthread(&A::inMsgRecList, &myobj);
	myOutthread.join();
	myInthread.join();
	
	return 0;
}

加了锁程序可以稳定运行不会再崩溃了，要记住if语句中每个分支都要unlock

unlock非常难排查所以引入了std::lock_guard类模板

lock_guard可以直接取代lock和unlock，使用lock_guard后不能使用lock和unlock了

mutex my_mutex;
lock_gurad<mutex> myLockGud(my_mutex);

void inMsgRecList() {
		for (int i = 0;i < 100000;i++) {
			cout << "inMsgRecList插入一个元素" << i << endl;
			lock_guard<mutex> myLockGuard(my_mutex);
			msgRecList.push_back(i);
		}
	}
	//从容其中取出数据
	void outMsgRecList() {
		for (int i = 0;i < 100000;i++) {
			lock_guard<mutex> myLockGuard(my_mutex);
			if (!msgRecList.empty()) {
				int msg = msgRecList.front();
				msgRecList.pop_front();
			}
			else {
				cout << "outMsgRecList执行，但List中为空" << endl;
			}
		}
		cout << "执行完了" << endl;
	}

lock_guard创建的时候调用构造函数lock，在函数执行结束前调用析构函数unlock，可以加上作用域使lock_guard提前析构

void inMsgRecList() {
		for (int i = 0;i < 100000;i++) {
			cout << "inMsgRecList插入一个元素" << i << endl;
            {
			    lock_guard<mutex> myLockGuard(my_mutex);
			    msgRecList.push_back(i);
            }
		}
	}
	//从容其中取出数据
	void outMsgRecList() {
		for (int i = 0;i < 100000;i++) {
			lock_guard<mutex> myLockGuard(my_mutex);
			if (!msgRecList.empty()) {
				int msg = msgRecList.front();
				msgRecList.pop_front();
			}
			else {
				cout << "outMsgRecList执行，但List中为空" << endl;
			}
		}
		cout << "执行完了" << endl;
	}

死锁

至少两个锁头(互斥量)才能产生死锁问题

using namespace std;
class A {
public:
	//收到数据，塞进容器中
	void inMsgRecList() {
		for (int i = 0;i < 100000;i++) {
			cout << "inMsgRecList插入一个元素" << i << endl;
			my_mutex1.lock();
			my_mutex2.lock();
			msgRecList.push_back(i);
			my_mutex1.unlock();
			my_mutex2.unlock();
		}
	}
	//从容其中取出数据
	void outMsgRecList() {
		for (int i = 0;i < 100000;i++) {
			my_mutex2.lock();
			my_mutex1.lock();
			if (!msgRecList.empty()) {
				int msg = msgRecList.front();
				msgRecList.pop_front();
				my_mutex1.unlock();
				my_mutex2.unlock();
			}
			else {
				cout << "outMsgRecList执行，但List中为空" << endl;
				my_mutex1.unlock();
				my_mutex2.unlock();
			}
		}
		cout << "执行完了" << endl;
	}
private:
	list<int> msgRecList;
	mutex my_mutex1;
	mutex my_mutex2;
};

int main() {
	A myobj;
	thread myOutthread(&A::outMsgRecList,&myobj);
	thread myInthread(&A::inMsgRecList, &myobj);
	myOutthread.join();
	myInthread.join();
	
	return 0;
}

解决死锁的办法

1.只要保证两个锁头的上锁顺序一致。

2.std::lock(mutex1,mutex2),

3.std::lock_guard<mutex> mylocgad(mutex1,std::adopt_lock);这个函数可以让lock_guard不执行构造函数，只执行析构函数，意思是可以手动lock，让lock_guard来帮助自动unlock，在lock的时候更加灵活了，在unlock的时候也更加方便了

class A {
public:
	//收到数据，塞进容器中
	void inMsgRecList() {
		for (int i = 0;i < 100000;i++) {
			cout << "inMsgRecList插入一个元素" << i << endl;
			std::lock(my_mutex1, my_mutex2);
			lock_guard<mutex> mylockguard1(my_mutex1,std::adopt_lock);
			lock_guard<mutex> mylockguard2(my_mutex2,std::adopt_lock);
			msgRecList.push_back(i);

		}
	}
	//从容其中取出数据
	void outMsgRecList() {
		for (int i = 0;i < 100000;i++) {
			std::lock(my_mutex1, my_mutex2);
			lock_guard<mutex> mylockguard1(my_mutex1, std::adopt_lock);
			lock_guard<mutex> mylockguard2(my_mutex2, std::adopt_lock);
			if (!msgRecList.empty()) {
				int msg = msgRecList.front();
				msgRecList.pop_front();
			}
			else {
				cout << "outMsgRecList执行，但List中为空" << endl;
			}
		}
		cout << "执行完了" << endl;
	}
private:
	list<int> msgRecList;
	mutex my_mutex1;
	mutex my_mutex2;
};

unique_lock

unique_lock比lock_guard灵活，但是效率第一点，内存占用高一点

unique_lock<mutex> my_unilock(my_mutex);

第一种使用方法与lock_guard没有区别

unique_lock第二个参数

std::adopt lock ，必须提前手动lock互斥量，不在此构造函数中lock

std::try_to_lock ，尝试去锁定互斥量，但如果没有锁定成功，会直接return不回阻塞。

unique_lock<mutex> myulock(my_mutex1,std::try_to_lock);
if(myulock.owns.lock()){
    //拿到了锁
    //可以操作全局数据
}else{
    //妹拿到锁，不能操作全局数据，但可以做点别的。
}

std::defer_lock

unique_lock<mutex> myulock(my_mutex1,std::try_to_lock);
//创建了一个my_mutex1的互斥量与myulock绑定，没有锁定，需要手动锁定
myulock.lock();