C++并发与多线程(4)-多个子线程创建

创建多个线程、数据共享、代码案例

1、创建和等待多个线程

先创建10个线程来看看：

#include <iostream>
#include <thread>
#include <vector>

using namespace std;

// 线程入口函数
void myprint(int inum) {

	cout << "myprint线程开始执行了，线程编号：" << inum << " 线程id：" << this_thread::get_id() << endl;
	cout << "myprint线程结束执行了，线程编号：" << inum << " 线程id：" << this_thread::get_id() << endl;

	return;

}

int main(int argc, char* argv[]) {

	// 1 、创建和等待多个线程
	vector<thread>mythreads;
	// 创建10个线程，线程入口函数统一使用myprint.
	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个线程都返回
	}

	cout << "I Love China!" << endl;//最后执行这句，整个进程退出

	return 0;
}

运行结果：

总结：
a）多个线程执行顺序是乱的，跟操作系统内部对线程的运行调度机制有关；
b）主线程等待所有子线程运行结束，最后主线程结束，推荐使用join()这种写法，更容易写出稳定的程序；
c) 把thread对象放入到容器里管理，看起来像thread对象数组，对一次创建大量线程并对大量线程进行管理很方便。

2、数据共享

2.1、只读数据

各个子线程对共享数据进行只读权限操作，是安全稳定的，不需要特殊的处理手段

#include <iostream>
#include <thread>
#include <vector>

using namespace std;

// 创建全局变量，该变量只用来读取
vector<int> g_v = { 1,2,3 };

// 线程入口函数
void myprint(int inum) {

	cout << "id为" << std::this_thread::get_id() << "的线程打印g_v值" << g_v[0] << g_v[1] << g_v[2] << endl;
	
	return;

}

int main(int argc, char* argv[]) {

	// 1 、创建和等待多个线程
	vector<thread>mythreads;
	// 创建10个线程，线程入口函数统一使用myprint.
	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个线程都返回
	}

	cout << "I Love China!" << endl;//最后执行这句，整个进程退出

	return 0;
}

运行结果：

2.2、有读有写

假设有2个线程写，8个线程读，如果代码没有特别处理，程序肯定崩溃；
最简单的不崩溃处理：读的时候不能写，写的时候不能读；两个线程不能同时写，八个线程不能同时读；
如果写的动作分10小步，执行到第二小步的时候切换到读线程，当读线程执行完再切换到写线程时指针位置就会发生不可预料的情况。由于任务切换导致各种诡异事情发生(最可能的就是崩溃)。

3、共享数据的保护案例

网络游戏服务器，假设有两个自己创建的线程：

1、 一个线程收集玩家命令（用一个数字来代表玩家发来的命令）并把命令数据写到一个队列中；
2、另外一个线程从队列中取出玩家发送来的命令，解析，执行玩家需要的动作；
3、list在频繁的按顺序插入和删除数据时效率高；vector对于随机的插入和删除数据时效率高；这里使用list。

使用成员函数作为线程函数的方法来写线程：

#include <iostream>
#include<thread>
#include<vector>
#include<list>

using namespace std;

class A {

public:

	// 把收到的消息（玩家命令）入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 10000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素 " << i << endl;
			msgRecvQueue.push_back(i);// 假设这个数字i就是我收到的命令，我直接弄到消息队列中来；
		}
	}

	// 把数据从消息队列中取出的线程：
	void outMsgRecvQueue()
	{
		for (int i = 0; i < 10000; ++i)
		{
			if (!msgRecvQueue.empty())
			{
				// 消息不为空
				int command = msgRecvQueue.front();// 返回第一个元素，但不检查元素是否存在；
				msgRecvQueue.pop_front();// 移除第一个元素，但不返回；
				// 这里就考虑处理数据……
				//……
			}
			else
			{
				// 消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空" << i << endl;
			}
		}
		cout << "end" << endl;
	}

private:
	std::list<int>msgRecvQueue;// 容器（消息队列），专门用于代表玩家给咱们发送过来的命令

};

int main(int argc, char* argv[])
{

	A myobja;
	thread myOutMsgObj(&A::outMsgRecvQueue, ref(myobja));// 第二个参数是引用，才能保证线程里用的是用一个对象
	thread myInMsgObj(&A::inMsgRecvQueue, ref(myobja));

	myOutMsgObj.join();
	myInMsgObj.join();

	return 0;
}

运行结果：

可以看到，不对共享数据进行处理，那么会导致线程执行异常，那么如何处理共享数据使得线程运行看全可靠呢？引入一个C++解决多线程保护共享数问题的第一个概念“互斥量”。请看下一章。