Th4：创建多个线程、数据共享问题分析、案例代码

 《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的数据），会出现程序异常！这是因为在本案例的代码中，读取共享数据和对共享数据的写入都是同时进行的，并没有让读取操作等待写入操作的完成，也没有让写入操作等待读取操作的完成，这在操作系统调度线程时就会出现问题。因此，我们将在下一小节中引入“互斥量”这一多线程中的重要概念。