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

一、创建和等待多个线程

1.代码

#include "stdafx.h"
#include <iostream>
#include <stdio.h>
#include <thread>
#include <vector>
using namespace std;


//可以很多个线程用同一个入口函数
//线程入口函数
void myCout(int inum)
{
	cout << "myCout线程开始执行了，线程编号 = " << inum << endl;
	//......
	cout << "myCout线程结束执行了，线程编号 = " << inum << endl;
	return;
}

//不是调用join，detach就是让线程执行了
//线程创建很容易，直接调用std::thread，就创建一个新线程了。该线程拿到任务后立即开始执行。
int main()
{
	//一、创建和等待多个线程

	//线程对象
	vector <thread> mythreads;
	//创建10个线程，线程入口函数统一使用myCout
	for (int i = 0; i < 10; i++)
	{
		//创建10个线程，同时这10个线程已经开始执行
		mythreads.push_back(thread(myCout, i));//临时对象放到容器里
	}

	//后创建的线程有可能先执行完


	//迭代器
	for (auto iter = mythreads.begin(); iter != mythreads.end(); ++iter)
	{
		//让所有子线程跟主线程汇合
		iter->join();//等待10个线程都返回 
	}


	//最后执行这句，整个进程退出
	cout << "这是主线程，主线程执行完，整个进程退出" << endl;

    return 0;
}

2.运行结果

3.分析

1. 多个线程执行顺序是乱的（可能先创建的进程后执行完），跟操作系统内部对线程的运行调度机制有关；
2. 主线程等待所有子线程运行结束，最后主线程结束，调用join的方式，更可以写出稳定的程序。
3. 把thread对象放入到容器里管理，看起来像个thread对象数组，这对我们一次创建大量的线程并对大量线程进行管理很方便。

二、数据共享问题分析

2.1 只读的数据

只读的数据，是安全稳定的，不需要特别什么处理手段。直接读就可以；

（1）代码

#include "stdafx.h"
#include <iostream>
#include <stdio.h>
#include <thread>
#include <vector>
using namespace std;


vector <int> g_v = { 1, 2, 3 };//共享数据,只读

//线程入口函数
void myCout(int inum)
{
	cout << "id为：" << std::this_thread::get_id() << "的线程 打印g_v的值" << g_v[0]  << ' ' << g_v[1] << ' ' << g_v[2] << ' ' << endl;
	return;
}

int main()
{
	vector <thread> mythreads;
	for (int i = 0; i < 10; i++)
	{
		mythreads.push_back(thread(myCout, i));
	}

	for (auto iter = mythreads.begin(); iter != mythreads.end(); ++iter)
	{
		iter->join();
	}
	cout << "主线程执行结束" << endl;

	return 0;
}

（2）运行结果

2.2 有读有写

例如：2个线程写，8个线程读，如果代码没有特别的处理，那程序肯定崩溃；
最简单的不崩溃处理，读的时候不能写，写的时候不能读。2个写线程不能同时写，8个读线程不能同时读；可能写的动作分10小步，由于任务切换，导致各种诡异的事情发生（最可能的诡异事情还是崩溃）；

2.3 其他案例

数据共享：例如两个窗口同时订票动作

三、共享数据的保护案例代码

• 网络游戏服务器：
• 两个自己创建的线程，一个线程收集玩家命令（用一个数字代表玩家发来的命令），并把命令数据写到一个队列中。
• 另外一个线程，从队列中取出玩家发送来的命令，解析，然后执行玩家需要的动作；
• vector 和 list：
• list：频繁的按顺序插入和删除数据时效率高；
• vector容器：随机的插入和删除数据效率高；
• 此处用成员函数作为线程函数的方法来写线程；

1.代码（存在问题）

//网络游戏服务器 
#include "stdafx.h"
#include <iostream>
#include <stdio.h>
#include <thread>
#include <vector>
#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())
			{
				//消息不为空
				//front() 返回第一个元素，但不检查元素是否存在；
				int command = msgRecvQueue.front();//从头取
				msgRecvQueue.pop_front();//移除第一个元素，但不返回
				//这里就要考虑处理数据...
				//......
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空" << i << endl;
			}
		}
		cout << "end" << endl;
	}
private:
	std::list<int> msgRecvQueue; //容器（消息队列），专门用于代表玩家给服务器发送过来的命令。
};
int main()
{
	A myobja;
	//类成员函数
	//第二个参数是 引用，才能保证线程里用的是同一个对象myobja。
	std::thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
	std::thread myInMsgObj(&A::inMsgRecvQueue, &myobja);

	//分析问题：
	//inMsgRecvQueue 不断的往容器里面写数据
	//outMsgRecvQueue 不断往容器里面读数据
	//两个线程有读有写，若是完全不控制随意运行就会有问题
	//就得按顺序按规矩去访问共享数据

	//代码化解决问题：
	//引入一个C++解决多线程保护共享数据问题的第一个概念“互斥量”。
	myOutnMsgObj.join();
	myInMsgObj.join();

	return 0;
}

2.问题

inMsgRecvQueue 不断的往容器里面写数据
outMsgRecvQueue 不断往容器里面读数据
两个线程有读有写，若是完全不控制随意运行就会有问题

3.代码化解决问题

引入一个C++解决多线程保护共享数据问题的第一个概念“互斥量”