《1》创建和等待多个线程
demo代码:(以下这个demo代码非常值得学习!!!)
#include<iostream>
#include<thread>
#include<vector>
using namespace std;
void myprint(int num) {//线程入口函数
cout << "myprint线程开始执行,线程编号为:" << num << endl;
//...do some works
cout<< "myprint线程结束执行" << endl;
}
int main(void) {
vector<thread> mythreads;
//创建10个线程,线程入口函数统一用myprint(int num)
for (int i = 0; i < 10; i++) {
mythreads.push_back(thread(myprint, i));
//创建了10个线程,同时这10个线程已经开始执行了!
}
for (auto iter = mythreads.begin(); iter != mythreads.end();iter++){
iter->join();//等待10个线程一起返回!
//一个线程执行完,再继续等另外一个!
}
//遍历线程数组的代码也可以写为:
//for (auto i = 0; i < mythreads.size();i++) {
// mythreads[i].join();//等待10个线程一起返回!
// //一个线程执行完,再继续等另外一个!
//}
cout << "主线程执行完毕,进程准备退出!" << endl;
return 0;
}
运行结果:
从结果可以分析出:
①多个线程的执行顺序是乱序的,这跟操作系统内部对于线程的运行调度机制有关。
②使用了.join()的方法让子线程先走其通路,最后再与主线程汇合,或者说主线程会等待所有的子线程运行结束。wjw老师推荐这种写法,因为这更容易写出稳定的多线程代码!
③把每个thread类线程放入vector容器中进行管理,看起来就像是一个thread对象数组,这非常有利于我们一次性创建大量线程并对其进行管理的操作!
《2》数据共享问题分析
2.1》只读的数据
对于只读的数据:使用线程访问它是安全稳定的,不需要任何特殊处理手段,直接读即可。
#include<iostream>
#include<thread>
#include<vector>
using namespace std;
const vector<int> vec{1,2,3};//只读的共享数据
void myprint(int num) {//线程入口函数
cout << "id为:" << std::this_thread::get_id() <<"\n vec: "<<vec[0] <<" "<<
vec[1] <<" "<< vec[2] << endl;
}
int main(void) {
vector<thread> mythreads;
for (int i = 0; i < 10; i++) {
mythreads.push_back(thread(myprint,i));//创建10个线程并让它们开始执行!
}
for (int i = 0; i < 10; i++) {
mythreads[i].join();//让10个子线程都执行完毕后再与主线程汇合!
}
cout << "主线程执行完毕,进程准备退出!" << endl;
return 0;
}
2.2》有读有写的数据
对于有读有写的数据:
- 若不加处理,程序肯定会崩溃
- 最简单的防止崩溃的处理方法:读的时候不能写,写的时候不能读。(比如,你创建了10个线程,其中有2个线程是写数据,8个线程读数据,此时我们可以让2个子线程不同时写,8个子线程不同时读)
- 再比如写的动作分10小步,由于任务切换,这会导致各种诡异的事情发生(最可能的还是崩溃)
《3》共享数据的保护案例代码
以开发一个简单的网络游戏服务器为案例:
现在我创建2个线程:
一个线程用于:收集玩家的命令,并把命令数据写到一个队列当中。
另一个线程用于:从队列中取出玩家发送来的命令,然后进行解析,然后再执行玩家所需要的动作。
#include<iostream>
#include<thread>
#include<list>
using namespace std;
class A {
public:
//把收到的消息(玩家命令)插入到消息容器中的线程函数
void inMsgRecvQueue() {
for (int i = 0; i < 100000; i++) {
cout << "inMsgRecvQueue()执行,插入一个元素: " << i << endl;
msgRecvQueue.push_back(i);//假设这个数字i就是我收到的命令
}
}
//把数据从消息容器中取出的线程函数
void outMsgRecvQueue() {
for (int i = 0; i < 100000; i++) {
if (!msgRecvQueue.empty()) {
//消息容器不为空时
int command = msgRecvQueue.front();//返回第一个元素,但是不检查元素是否存在
msgRecvQueue.pop_front();//移除消息容器中的首元素
//处理数据完毕...
}
else {
//消息容器为空时
cout << "outMsgRecvQueue()执行,但是目前消息容器为空!(无消息)" << i << endl;
}
}
cout << "处理消息的容器执行完毕了!!!" << endl;
}
private:
list<int> msgRecvQueue;
};
int main(void) {
A mytobj;
thread Inthread(&A::inMsgRecvQueue, &mytobj);//&mytobj也可以写为std::ref(mytobj)
//也只有这样才能够传真正的引用进去到线程函数中!
thread Outthread(&A::outMsgRecvQueue, &mytobj);
Inthread.join();
Outthread.join();
cout << "主线程执行完毕,进程准备退出!" << endl;
return 0;
}
但是,当我们执行这段代码时,就会发现一个问题,在多线程共享数据时(在这里就是2个线程共享同一份A类对象mytobj的数据),会出现程序异常!这是因为在本案例的代码中,读取共享数据和对共享数据的写入都是同时进行的,并没有让读取操作等待写入操作的完成,也没有让写入操作等待读取操作的完成,这在操作系统调度线程时就会出现问题。因此,我们将在下一小节中引入“互斥量”这一多线程中的重要概念。