C++多线程

• 创建多个线程
• 数据共享（读、写）
• 互斥量概念、用法
• 死锁概念、死锁解决
• 一些实例

// 多线程3.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
using namespace std;


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

//线程入口函数
void myprint(int inum)
{
	cout << "myprint线程开始执行了，线程编号=" << inum << endl;
	//....
	cout<<"线程结束执行了，线程编号=" << inum << endl;
	return;
}

//线程入口函数
void share_print(int inum)   
{
	cout << "线程id为" << std::this_thread::get_id() << "打印共享数据" << share_num[0] << share_num[1] << share_num[2] << endl;
	return;
}

//一个不具备mutex的普通类
class A {
public: 
	
	void inMsgRecvQueue()  //把收到的消息（玩家命令）到一个队列的线程。100000次便于观察
	{
		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 << "end" << endl;
	}
private:
	list <int> msgRecvQueue; //容器(消息队列)，专门用于代表玩家发送过来的命令
};


//具备mutex的类
class A_Mutex {
public:

	void inMsgRecvQueue()  //把收到的消息（玩家命令）到一个队列的线程。100000次便于观察
	{
		for (int i = 0; i < 100000; i++)
		{
			cout << "inMsgRecvQueue()执行,插入一个元素" << i << endl;

			{   //加上大括号可以让lock_guard提前（在处理其他代码前）解锁（超出作用域时（大括号）析构）
				//lock_guard <mutex> guard(my_mutex);
				//lock_guard <mutex> guard2(my_mutex2);

				//std::lock(my_mutex, my_mutex2);

				//lock_guard <mutex> guard(my_mutex,adopt_lock);
				//lock_guard <mutex> guard2(my_mutex2,adopt_lock);
				my_mutex2.lock();
				//...处理代码
				my_mutex.lock();
				msgRecvQueue.push_back(i); //假设这个数字i就是我收到的命令，直接送到消息队列里去
				my_mutex.unlock();
				my_mutex2.unlock();
			}
			//....处理其他代码
		}
		return;
	}

	bool outMsgLULProc(int &command)  
	{
		//lock_guard <mutex> guard(my_mutex);   //guard为对象名,使用lock_guard时，lock与unlock不能再使用
		//lock_guard <mutex> guard2(my_mutex2);
		//std::lock(my_mutex, my_mutex2);
		my_mutex2.lock();
		//执行一些代码...
		my_mutex.lock();
		if (!msgRecvQueue.empty()) //消息不为空
		{
			command = msgRecvQueue.front();//返回第一个元素
			msgRecvQueue.pop_front();//弹出第一个元素（移除）
			my_mutex2.unlock();
			my_mutex.unlock();
			return true;
		}
		 //注意这里也有一个unlock(另外一个出口也需要unlock)
		my_mutex2.unlock();
		my_mutex.unlock();
		return false;
		
	}
	void outMsgRecvQueue()//把数据从消息队列中取出的线程
	{
		int command = 0;
		for (int i = 0; i < 100000; i++)
		{
			if (outMsgLULProc(command)==true)
			{
				cout << "outMsgRecvQueue()执行" << i << endl;
				//可以对command进行数据处理
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列为空" << i << endl;
			}
		}
		cout << "end" << endl;
		return;
	}
private:
	list <int> msgRecvQueue; //容器(消息队列)，专门用于代表玩家发送过来的命令
	mutex my_mutex; //创建了一个互斥量（一个锁）
	mutex my_mutex2; //创建了另外一个互斥量（另一个锁）
};


int main()
{
	//一:创建和等待多个线程
	//vector <thread> mythreads;
	//创建10个线程，线程入口函数统一用myprint
	//1.多个线程执行顺序是乱的，跟操作系统内部对线程的运行调度机制有关
	//2.join时，主线程等待所有子线程运行结束，再结束主线程。更容易写出稳定的程序
	//3.把thread对象放入容器里管理（类似于thread对象数组），方便一次创建大量的线程与管理
	//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();//等待十个线程都返回
	//}
	//cout << "主线程执行完毕" << endl; //执行完这句，主线程退出


	//二：数据共享问题分析
	//（2.1）只读的数据，是安全稳定的，不需要特别的处理手段，直接读就可以
	//vector <thread> share_threads;
	//for (int i = 0; i < 10; i++)
	//{
	//	mythreads.push_back(thread(share_print, i)); //创建10个线程，同时这10个线程已开始执行
	//}
	//for (auto iter = mythreads.begin(); iter != mythreads.end(); iter++)
	//{
	//	iter->join();//等待十个线程都返回
	//}
	//cout << "主线程执行完毕" << endl; //执行完这句，主线程退出

	//(2.2)有读有写：2个线程写，8个线程读，如果代码没有特殊处理，程序肯定崩溃
	//最简单的处理：读的时候不能写， 写的时候不能读。两个线程不能同时写，八个线程不能同时读


	//三：共享数据的保护案例
	//网络游戏服务器。两个自己创建的线程，一个线程收集玩家命令（用一个数字代表玩家发来的命令），并把命令数据写到一个队列中
	//另外一个线程，从队列中取出玩家发送来的命令，解析，然后执行玩家需要的动作 
	//list就是数据结构中的双向链表，因此它的内存空间可以是不连续的，通过指针来进行数据的访问，这个特点使得它的随机存取变的非常没有效率
	//因此它没有提供[]操作符的重载。但由于链表的特点，它可以以很好的效率支持任意地方的删除和插入。
	//A myobja;
	//thread myOutnMsgObj(&A::outMsgRecvQueue,&myobja);  //第二参数是引用（就无需拷贝），才能保证线程里用的是同一对象
	//thread myInMsgobj(&A::inMsgRecvQueue, &myobja);
	//myOutnMsgObj.join();
	//myInMsgobj.join();
	//如果直接这样运行（对共享数据同时进行读写），程序会崩溃。在此引入一个多线程保护共享数据的的一个概念“互斥量”

	//四：互斥量（mutex）
	//保护共享数据：某个线程先用代码把共享数据锁住，再操作数据，操作完再解锁。其他想操作共享数据的必须等待解锁，等解锁后再锁定、操作、解锁。
	//互斥量就是个类对象，理解为一把锁，多个线程尝试用lock（）成员函数来加锁。多个线程只有一个线程能锁定成功（成功的标志是lock（）函数返回），如果没锁成功，线程则会卡在lock()里（线程会不断尝试去加锁）
	//互斥量使用要小心，保护的数据要正正好好，少了会达不到保护效果，多了会影响效率

	//五：互斥量的用法
	//（5.1）lock()和unlock()
	//步骤：先lock()成功,再操作共享数据，再unlock()
	//lock与unlock必须成对使用

	//A_Mutex myobj_mutex;
	//thread myOutnMsgObj(&A_Mutex::outMsgRecvQueue,&myobj_mutex);  //第二参数是引用（就无需拷贝），才能保证线程里用的是同一对象
	//thread myInMsgobj(&A_Mutex::inMsgRecvQueue, &myobj_mutex);
	//myOutnMsgObj.join();
	//myInMsgobj.join();

	//（5.2）std::lock_guard类模板，直接取代lock()和unlock()。（使用lock_guard时，lock与unlock不能再使用）
	//有lock,忘记unlock的问题非常难排查。为了防止忘记unlock，引入了一个叫std::lock_guard的类模板：忘记unlock，帮忙unlock
	//lock_guard的构造函数执行了mutex::lock();lock_guard的析构函数执行了mutex::unlock()

	//六：死锁
	//至少两个互斥量：mutex_A,mutex_B,mutex_C ....
	//一个线程lock了mutex_A,然后申请lock mutex_B;  此时另外一个线程lock了mutex_B,然后申请lock mutex_A。造成互相等待，死锁。
	
	//（6.1）死锁演示
	//创建两个互斥量（两把锁）
	//一个进程先申请mutex_A再申请mutex_B；另外一个进程先申请mutex_B再申请mutex_A

	A_Mutex myobj_mutex;
	thread myOutnMsgObj(&A_Mutex::outMsgRecvQueue, &myobj_mutex);  //第二参数是引用（就无需拷贝），才能保证线程里用的是同一对象
	thread myInMsgobj(&A_Mutex::inMsgRecvQueue, &myobj_mutex);
	myOutnMsgObj.join();
	myInMsgobj.join();

	//(6.2)死锁的一般解决方案
	//只要保证这两个进程对这两个互斥量的上锁顺序一致就不会死锁,lock_guard同理

	//(6.3)std::lock()函数模板: std::lock(mutex_A,mutex_B,mutex_C,...)，需与mutex_A.unlock()...配套使用
	//能力：一次锁住两个或者两个以上的互斥量（至少两个，多了不限，1个不行）（要么全锁，要么都不锁） （谨慎使用，推荐一个一个锁）
	//使用该函数模板，不存在 多个线程因上锁顺序不一致导致死锁 的问题
	//一旦有一个互斥量没锁住，就释放手上已锁的其他互斥量并等待，直到锁住了所有的互斥量才往下走。

	//(6.4)std::lock与std::guard配合使用（则不需要手动添加unlock）
	//使用方法如下：
	//std::lock(my_mutex, my_mutex2);
	//lock_guard <mutex> guard(my_mutex,std::adopt_lock);  //adopt_lock参数：可选择的lock，起标志作用（表示互斥量已经lock过了，guard调用构造函数时不会再去lock）
	//lock_guard <mutex> guard2(my_mutex2,std::adopt_lock);
	
	
	cout << "主线程执行完毕" << endl; //执行完这句，主线程退出
	return 0;
   
}