C++多线程之互斥量
在学习互斥量之前，我们要清楚什么情况下需要使用互斥量，第一个例子中有一段共享数据g_v，在main()函数中创建了10个线程，这10个线程的入口函数均为myprint()，在函数中打印出共享数据，代码如下：
#include<map>
#include<iostream>
#include<thread>
#include<list>
#include<mutex>
#include<string>
#include<vector>
using namespace std;
vector<int> g_v = { 1,2,3 }; //共享数据
void myprint(int inum)
{
//多个线程可以用同一个线程入口函数
/*cout << "myprint线程开始执行，线程编号是：" << inum << endl;
cout << "myprint线程结束了，线程编号是：" << inum << endl;*/
cout << "id=" << this_thread::get_id() << "的线程，打印g_v值" << g_v[0] << g_v[1] << g_v[2] << endl;
return;
}
int main()
{
//创建和等待多个线程
vector<thread> mythread;
for (int i = 0; i < 10; i++)
{
mythread.push_back(thread(myprint, i));//创建并开始执行线程
}
for (auto iter = mythread.begin(); iter!=mythread.end();iter++)
{
iter->join();
}
cout << "main thread gg" << endl;
//数据共享问题
return 0;
}
运行结果如下：
可以看到程序正常运行，说明只读数据的共享是安全稳定的，不需要特别的处理手段
我们再来看看有读有写的数据的情况，程序背景如下：
–>模拟一个网络游戏服务器，
服务器有两个线程，一个线程用于收集玩家命令（范例中简化用一个数组代表），并把命令写到一个队列中。
另一个线程用于从队列中取出玩家发出的命令，解析，执行玩家需要的动作。
代码如下：
#include<map>
#include<iostream>
#include<thread>
#include<list>
#include<mutex>
#include<string>
#include<vector>
using namespace std;
class A
{
public:
//线程一，入队列
void inMsgRecvQ()
{
for (int i = 0; i < 100000; i++)
{
cout << "接收消息的线程执行，插入一个元素 " << i << endl;
msgRecvQ.push_back(i);//假设数字i就是玩家收到的命令
}
}
//线程二，从消息队列中去数据
void outMsgRecvQ()
{
for (int i = 0; i < 100000; i++)
{
if (!msgRecvQ.empty())
{
//表示消息队列不为空
int command = msgRecvQ.front();//返回第一个元素，但不检查元素是否存在
msgRecvQ.pop_front(); //移除第一个元素，不返回
}
else
{
cout << "读取消息队列执行，但目前队列中没有信息！ " << i << endl;
}
}
cout << "线程二执行完毕！" << endl;
}
private:
list<int> msgRecvQ;//容器，用于接收玩家发过来的命令
};
int main()
{
A myTask;
thread myOutMsgThread(&A::outMsgRecvQ, &myTask);//第二个参数是引用类型，这样才能保证线程里用的是同一个对象
thread myInMsgThread(&A::inMsgRecvQ, &myTask);
myInMsgThread.join();
myOutMsgThread.join();
return 0;
}
执行结果如下：
处理程序奔溃，因为在线程二读取队列内容时线程一也在插入数据，导致了不确定性。最简单的处理是读写不能同时进行，不能同时写，不能同时读。为了保护共享数据我们引入了“互斥量mutex”，
先lock(),操作共享数据，再unlock(),lock()和unlock()必须成对使用。
在使用mutex前，先声明mutex my_mutex;具体使用如下：
#include<map>
#include<iostream>
#include<thread>
#include<list>
#include<mutex>
#include<string>
#include<vector>
using namespace std;
class A
{
public:
//线程一，入队列
void inMsgRecvQ()
{
for (int i = 0; i < 100000; i++)
{
cout << "接收消息的线程执行，插入一个元素 " << i << endl;
my_mutex.lock();
msgRecvQ.push_back(i);//假设数字i就是玩家收到的命令
my_mutex.unlock();
}
}
bool outMsgDispose(int &command)
{
my_mutex.lock();
if (!msgRecvQ.empty())
{
//表示消息队列不为空
int command = msgRecvQ.front();//返回第一个元素，但不检查元素是否存在
msgRecvQ.pop_front(); //移除第一个元素，不返回
my_mutex.unlock();
return true;
}
my_mutex.unlock();
return false;
}
//线程二，从消息队列中去数据
void outMsgRecvQ()
{
int comment = 0;
for (int i = 0; i < 100000; i++)
{
bool result = outMsgDispose(comment);
if (result==true)
{
cout << "线程一执行，取出一个元素" << comment << endl;
}
else
{
cout << "读取消息队列执行，但目前队列中没有信息！ " << i<<endl;
}
}
cout << "线程二执行完毕！" << endl;
}
private:
list<int> msgRecvQ;//容器，用于接收玩家发过来的命令
mutex my_mutex;
};
int main()
{
A myTask;
thread myOutMsgThread(&A::outMsgRecvQ, &myTask);//第二个参数是引用类型，这样才能保证线程里用的是同一个对象
thread myInMsgThread(&A::inMsgRecvQ, &myTask);
myInMsgThread.join();
myOutMsgThread.join();
return 0;
}
正常运行，如下：
为了防止大家忘记unlock(),C++中引入了std::lock_guard的类模板。
std::lock_guard可以直接取代lock()和unlock(),也就是说你使用lock_guard()后就不能使用lock()和unlock()了。
lock_guard my_guard(my_mutex);
lock_guard构造函数里执行了mutex::lock(),析构函数里执行了mutex::unlock().
程序也能正常运行。
