文章目录
1、互斥量的基本概念
当对共享数据进行操作时,为了防止线程冲突,我们应该使某个线程用代码把共享数据锁住,然后操作数据,最后解锁;其他线程想操作共享数据的线程必须等待解锁,锁定住,操作,解锁。这就引出了一个名词概念:互斥量。
**互斥量(mutex)基本概念:**互斥量是个类对象,理解成一把锁,多个线程尝试用互斥量这个类对象的成员函数lock()
来加锁这把锁头。只有一个线程能锁定成功(成功的标志是lock()
函数返回),如果没锁成功,那么流程卡在lock()
这里不断不断尝试去锁这把锁头。
- 互斥量使用要小心,保护数据不多也不少,少了,没达到保护效果,多了,影响效率。
2、互斥量的用法
2.1 lock(),unlock()
- 步骤:先
lock()
,然后操作共享数据,最后unlock()
。 lock()
和unlock()
要成对使用,有lock()
必然要有unlock()
,每调用一次lock()
,必然应该调用一次unlock()
。- 不应该也不允许调用1次
lock()
却调用了2次unlcok()
,也不允许调用2次lock()
却只调用了1次unlcok()
,这些非对称数量的调用都会导致代码不稳定,甚至崩溃。
示例代码:
#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)入到一个队列的线程
void inMsgRecvQueue()
{
for (int i = 0; i < 10000; i++)
{
my_mutex.lock();
cout << "inMsgRecvQueue()执行,插入一个元素:" << i << endl;
msgRecvQueue.push_back(i);
my_mutex.unlock();
}
return;
}
bool outMsgLULProc(int& command)
{
my_mutex.lock();
if (!msgRecvQueue.empty())
{
//消息不为空
command = msgRecvQueue.front(); //返回第一个元素,但不检查元素是否存在
msgRecvQueue.pop_front(); //移除第一个元素,但不返回
my_mutex.unlock();
return true;
}
my_mutex.unlock();
return false;
}
//把数据从消息队列中取出的线程
void outMsgRecvQueue()
{
int command = 0;
for (int i = 0; i < 10000; i++)
{
bool result = outMsgLULProc(command);
if (result == true)
{
cout << "outMsgRecvQueue()执行,取出一个元素" << command << endl;
//接下来就考虑处理数据......
}
else
{
//消息队列为空
cout << "outMsgRecvQueue()执行,但目前消息队列中为空" << i << endl;
}
}
}
private:
list<int> msgRecvQueue; //容器,专门用于代表玩家给咱们发送过来的命令
mutex my_mutex; //创建了一个互斥量
};
int main()
{
A myobja;
thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
myInMsgObj.join();
myOutnMsgObj.join();
cout << "I live China!" << endl; //最后执行这句,整个进程退出
system("pause");
return 0;
}
- 注意:有
lock()
,忘记unlock()
的问题,非常难排查。 - 为了防止大家忘记
unlock()
,引入了一个叫std::lock_guard
的类模板——忘记unlock()
不要紧,我替你unlock()
。
2.2 std::lock_guard
std::lock_guard
:类模板,直接取代lock()
和unlock()
- 用了
lock_guard
之后,再也不能使用lock()
和unlock()
。 lock_guard
构造函数里执行了mutex::lock()
。lock_guard
析构函数里执行了mutex::unlock()
。- 当使用
lock_guard
时,如果想要提前解锁,可以在为执行的代码部分添加{}
,则代码块内的变量的生命周期和作用域将被限制在该代码块内,即lock_guard
类变量在出代码块时将会执行析构。
示例代码:
#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)入到一个队列的线程
void inMsgRecvQueue()
{
for (int i = 0; i < 10000; i++)
{
cout << "inMsgRecvQueue()执行,插入一个元素:" << i << endl;
{
std::lock_guard<std::mutex> sbguard(my_mutex);
msgRecvQueue.push_back(i);
}
}
return;
}
bool outMsgLULProc(int& command)
{
std::lock_guard<std::mutex> sbguard(my_mutex);
if (!msgRecvQueue.empty())
{
//消息不为空
command = msgRecvQueue.front(); //返回第一个元素,但不检查元素是否存在
msgRecvQueue.pop_front(); //移除第一个元素,但不返回
return true;
}
return false;
}
//把数据从消息队列中取出的线程
void outMsgRecvQueue()
{
int command = 0;
for (int i = 0; i < 10000; i++)
{
bool result = outMsgLULProc(command);
if (result == true)
{
cout << "outMsgRecvQueue()执行,取出一个元素" << command << endl;
//接下来就考虑处理数据......
}
else
{
//消息队列为空
cout << "outMsgRecvQueue()执行,但目前消息队列中为空" << i << endl;
}
}
}
private:
list<int> msgRecvQueue; //容器,专门用于代表玩家给咱们发送过来的命令
mutex my_mutex; //创建了一个互斥量
};
int main()
{
A myobja;
thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
myInMsgObj.join();
myOutnMsgObj.join();
cout << "I live China!" << endl; //最后执行这句,整个进程退出
system("pause");
return 0;
}
3、死锁
- 死锁这个问题,至少两个锁头也就是两个互斥量才能产生。
- 死锁就是资源访问冲突,互不相让,形成死循环。
3.1 死锁演示
#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)入到一个队列的线程
void inMsgRecvQueue()
{
for (int i = 0; i < 10000; i++)
{
cout << "inMsgRecvQueue()执行,插入一个元素:" << i << endl;
//先锁1后锁2
my_mutex1.lock(); //实际工程中这两个锁头不一定挨着,可能他们需要保护不同的数据共享块;
my_mutex2.lock();
msgRecvQueue.push_back(i);
my_mutex2.lock();
my_mutex1.unlock();
}
return;
}
bool outMsgLULProc(int& command)
{
//先锁2后锁1
my_mutex2.lock();
my_mutex1.lock();
if (!msgRecvQueue.empty())
{
//消息不为空
command = msgRecvQueue.front(); //返回第一个元素,但不检查元素是否存在
msgRecvQueue.pop_front(); //移除第一个元素,但不返回
my_mutex1.unlock();
my_mutex2.unlock();
return true;
}
my_mutex1.unlock();
my_mutex2.unlock();
return false;
}
//把数据从消息队列中取出的线程
void outMsgRecvQueue()
{
int command = 0;
for (int i = 0; i < 10000; i++)
{
bool result = outMsgLULProc(command);
if (result == true)
{
cout << "outMsgRecvQueue()执行,取出一个元素" << command << endl;
//接下来就考虑处理数据......
}
else
{
//消息队列为空
cout << "outMsgRecvQueue()执行,但目前消息队列中为空" << i << endl;
}
}
}
private:
list<int> msgRecvQueue; //容器,专门用于代表玩家给咱们发送过来的命令
mutex my_mutex1; //创建了一个互斥量
mutex my_mutex2; //创建了另一个互斥量
};
int main()
{
A myobja;
thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
myInMsgObj.join();
myOutnMsgObj.join();
cout << "I live China!" << endl; //最后执行这句,整个进程退出
system("pause");
return 0;
}
上述线程函数inMsgRecvQueue()
中是先锁1后锁2,而线程函数outMsgRecvQueue
中则是先锁2后锁1,这就造成了死锁,当程序运行时就会出现一致互相等待的状况。
3.2 死锁的一般解决方案
- 只要保证这两个互斥量上锁的顺序一致就不会死锁。
示例代码:
#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)入到一个队列的线程
void inMsgRecvQueue()
{
for (int i = 0; i < 10000; i++)
{
cout << "inMsgRecvQueue()执行,插入一个元素:" << i << endl;
std::lock_guard <mutex> sbguard1(my_mutex1);
std::lock_guard <mutex> sbguard2(my_mutex2);
//my_mutex1.lock(); //实际工程中这两个锁头不一定挨着,可能他们需要保护不同的数据共享块;
//my_mutex2.lock();
msgRecvQueue.push_back(i);
//my_mutex2.unlock();
//my_mutex1.unlock();
}
return;
}
bool outMsgLULProc(int& command)
{
std::lock_guard <mutex> sbguard1(my_mutex1);
std::lock_guard <mutex> sbguard2(my_mutex2);
//my_mutex1.lock();
//my_mutex2.lock();
if (!msgRecvQueue.empty())
{
//消息不为空
command = msgRecvQueue.front(); //返回第一个元素,但不检查元素是否存在
msgRecvQueue.pop_front(); //移除第一个元素,但不返回
//my_mutex2.unlock();
//my_mutex1.unlock();
return true;
}
//my_mutex2.unlock();
//my_mutex1.unlock();
return false;
}
//把数据从消息队列中取出的线程
void outMsgRecvQueue()
{
int command = 0;
for (int i = 0; i < 10000; i++)
{
bool result = outMsgLULProc(command);
if (result == true)
{
cout << "outMsgRecvQueue()执行,取出一个元素" << command << endl;
//接下来就考虑处理数据......
}
else
{
//消息队列为空
cout << "outMsgRecvQueue()执行,但目前消息队列中为空" << i << endl;
}
}
}
private:
list<int> msgRecvQueue; //容器,专门用于代表玩家给咱们发送过来的命令
mutex my_mutex1; //创建了一个互斥量
mutex my_mutex2; //创建了另一个互斥量
};
int main()
{
A myobja;
thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
myInMsgObj.join();
myOutnMsgObj.join();
cout << "I live China!" << endl; //最后执行这句,整个进程退出
system("pause");
return 0;
}
3.3 std::lock()函数模板
std::lock()
- 一次锁住两个或者两个以上的互斥量(至少两个,多了不限,一个不行)。
- 它不存在这种因为在多个线程中,因为锁的顺序问题导致死锁的风险问题。
- 要么两个互斥量都锁住,要么两个互斥量都没锁住。如果只锁了一个,另外一个没锁成功,则它立即把已经锁住的解锁。
- 用来处理多个互斥量的时候才出场。
示例代码:
#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)入到一个队列的线程
void inMsgRecvQueue()
{
for (int i = 0; i < 10000; i++)
{
cout << "inMsgRecvQueue()执行,插入一个元素:" << i << endl;
std::lock(my_mutex1, my_mutex2); //相当于每个互斥量都调用了.lock()
msgRecvQueue.push_back(i);
my_mutex1.unlock();
my_mutex2.unlock();
}
return;
}
bool outMsgLULProc(int& command)
{
std::lock(my_mutex1, my_mutex2); //相当于每个互斥量都调用了.lock()
if (!msgRecvQueue.empty())
{
//消息不为空
command = msgRecvQueue.front(); //返回第一个元素,但不检查元素是否存在
msgRecvQueue.pop_front(); //移除第一个元素,但不返回
my_mutex1.unlock();
my_mutex2.unlock();
return true;
}
my_mutex1.unlock();
my_mutex2.unlock();
return false;
}
//把数据从消息队列中取出的线程
void outMsgRecvQueue()
{
int command = 0;
for (int i = 0; i < 10000; i++)
{
bool result = outMsgLULProc(command);
if (result == true)
{
cout << "outMsgRecvQueue()执行,取出一个元素" << command << endl;
//接下来就考虑处理数据......
}
else
{
//消息队列为空
cout << "outMsgRecvQueue()执行,但目前消息队列中为空" << i << endl;
}
}
}
private:
list<int> msgRecvQueue; //容器,专门用于代表玩家给咱们发送过来的命令
mutex my_mutex1; //创建了一个互斥量
mutex my_mutex2; //创建了另一个互斥量
};
int main()
{
A myobja;
thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
myInMsgObj.join();
myOutnMsgObj.join();
cout << "I live China!" << endl; //最后执行这句,整个进程退出
system("pause");
return 0;
}
3.4 std::lock_guard的std::adopt_lock参数
- 一定要在
std::lock
后再用std::lock_guard
,std::adopt_lock
会略过lock()
步骤,在结束析构的时候自动执行unlock()
。 std::adopt_lock
是个结构体对象,起一个标记作用。std::adopt_lock
就是表示这个互斥量已经执行了lock()
,不需要在std::lock_guard<std::mutex>
里面对对象再次进行lock()
了。
示例代码:
#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
using namespace std;
class A
{
public:
//把收到的消息(玩家命令)入到一个队列的线程
void inMsgRecvQueue()
{
for (int i = 0; i < 10000; i++)
{
cout << "inMsgRecvQueue()执行,插入一个元素:" << i << endl;
std::lock(my_mutex1, my_mutex2); //相当于每个互斥量都调用了.lock()
std::lock_guard<std::mutex> sbguard1(my_mutex1,std::adopt_lock);
std::lock_guard<std::mutex> sbguard2(my_mutex2, std::adopt_lock);
msgRecvQueue.push_back(i);
}
return;
}
bool outMsgLULProc(int& command)
{
std::lock(my_mutex1, my_mutex2); //相当于每个互斥量都调用了.lock()
std::lock_guard<std::mutex> sbguard1(my_mutex1, std::adopt_lock);
std::lock_guard<std::mutex> sbguard2(my_mutex2, std::adopt_lock);
if (!msgRecvQueue.empty())
{
//消息不为空
command = msgRecvQueue.front(); //返回第一个元素,但不检查元素是否存在
msgRecvQueue.pop_front(); //移除第一个元素,但不返回
return true;
}
return false;
}
//把数据从消息队列中取出的线程
void outMsgRecvQueue()
{
int command = 0;
for (int i = 0; i < 10000; i++)
{
bool result = outMsgLULProc(command);
if (result == true)
{
cout << "outMsgRecvQueue()执行,取出一个元素" << command << endl;
//接下来就考虑处理数据......
}
else
{
//消息队列为空
cout << "outMsgRecvQueue()执行,但目前消息队列中为空" << i << endl;
}
}
}
private:
list<int> msgRecvQueue; //容器,专门用于代表玩家给咱们发送过来的命令
mutex my_mutex1; //创建了一个互斥量
mutex my_mutex2; //创建了另一个互斥量
};
int main()
{
A myobja;
thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
myInMsgObj.join();
myOutnMsgObj.join();
cout << "I live China!" << endl; //最后执行这句,整个进程退出
system("pause");
return 0;
}
3.5 总结
std::lock
:一次锁定多个互斥量,谨慎使用。- 实际工程中每个互斥量保护着不同的代码段,因此使用一次锁定的情况很少用,建议一个一个锁。
注:本人学习c++多线程视频地址:C++多线程学习地址