多线程简单实用

#include "pch.h"
#include <iostream>
#include<vector>
#include<mutex>
#include<thread>
#include<list>

class A
{
public:
	std::mutex t_mutex1;
	std::mutex t_mutex2;
	/*A operator()()
	{
		std::cout << "A类重载函数作为线程参数!" <<std:: endl;
	}*/
	std::list<int> msgManage;
	A()
	{
		std::cout << "A 构造函数调用!" << std::endl;
	}

	A(A&t_obj)
	{
		msgManage = t_obj.msgManage;
		std::cout << "A 拷贝构造函数调用!" << std::endl;
	}
	~A()
	{
		std::cout << "A 析构函数调用!" << std::endl;
	
	}
	void msg_recieve()
	{
	//	t_mutex.lock();
		/*std::lock_guard<std::mutex> t_guard1(t_mutex1);
		std::lock_guard<std::mutex> t_guard2(t_mutex2);*/
		
		for (auto i = 0; i < 1000; i++)
		{
			t_mutex1.lock();
			t_mutex2.lock();
			msgManage.push_back(i);
			std::cout << "msg_recieve ..........." << std::endl;
			t_mutex1.unlock();
			t_mutex2.unlock();
		}
		
	}
	void msg_send()
	{
	/*	std::lock_guard<std::mutex> t_guard2(t_mutex2);
		std::lock_guard<std::mutex> t_guard1(t_mutex1);*/
		
		for (auto i = 0; i < 1000; i++)
		{
			t_mutex1.lock();
			t_mutex2.lock();
		//	std::cout << "msgMangage:" << msgManage.size() << std::endl;
			
			if (!msgManage.empty())
			{
				int t_msg = msgManage.front();
				msgManage.pop_front();
				std::cout << "msg_send..............." << std::endl;
				

				t_mutex1.unlock();
				t_mutex2.unlock();
			}
			
		}

	}

};



int main()
{
	A t_obj1;

	std::thread t_thread_1(&A::msg_recieve,&t_obj1);
	std::thread t_thread_2(&A::msg_send, &t_obj1);
	t_thread_2.join();
	t_thread_1.join();

    std::cout << "Hello World!\n"; 
}


//并发与多线程：
//并发指一个程序同时独立处理多个任务
//多线程是解决并发的一种常用手段，使用方法如下：
//定义多个子线程，每个线程相当于一条程序通路，多个子线程同时工作，即几条通路同时运行。
//结论：1.使用join阻塞，2.少用指针和引用，多构建临时对象作为线程函数的参数。3.使用mutex解决
//线程间数据一致性问题(互斥量),std::lock_guard类模板可以取代lock()和unlock()。

//死锁：至少有两把锁,并且两把锁同时锁上，才能继续运行，不然继续尝试上锁
//产生原因：1.线程a，先锁mutex1，再锁mutex2;线程2，先锁mutex2，再锁mutex1.
//2.当线程a，锁上mutex1，恰好操作系统完成上下文切换，执行线程b，线程b也成功锁上mutex2，继续尝试锁上mutex1
//但是，mutex1已经被锁上了只能继续等待解锁，此时便发生了死锁。
//死锁解决办法：1.各个线程上锁的顺序保持一致，便不会发生死锁.
//2.可以使用std::lock()