多线程学习之二

1）线程的一些常识

1）进程：就是运行起来的可执行程序；
2）线程：一条代码的执行通路；
3）全局变量，指针，引用都可以在线程之间传递；
4）主线程从main函数开始，子线程也得从函数开始，一旦这个函数运行完毕，就代表我们这个线程结束！
5）在线程中，join是有【汇合】等待的意思，延伸为等待，就是主线程要等待子线程汇合后再执行，所以主线程要阻塞！
      join这个函数很重要，决定了程序的执行顺序；
     传统多线程程序是主线程要等待子线程执行完后，自己最后退出；
6）为什么引入detach(),因为一个主线程等待多个子线程执行完再继续执行，编程方法过于保守；
      detach分离后，子线程就会驻留在后台运行，这个子线程相当于被C++运行时库接管，当子线程运行完，运行时库清理该子线程的资源！
      驻留到后台的线程叫【守护线程】；
7)   joinable()判断是否使用join()或者detach();
8)  lambda表达式作为线程参数
9)  在写线程的时候，当处理子线程和主线程的关系的时候，时刻想着join和detach这两个函数，时刻要明确，用detach是否安全！
int main() //上述代码
{
	auto fun = []() {cout << "12344444" << endl; };
	std::thread th(fun);
	th.join();
	return 0;
}
9）类对象（仿函数）作为线程参数
class A
{
public:
	A(int tmp):m_(tmp){ cout << "构造函数" << endl; }
	A(const A& obj):m_(obj.m_)
	{
		cout << "拷贝构造函数"<< endl;
	}
	~A()
	{
		cout << "析构函数---" << endl;
	}
	void operator()() //不能带参数！！！否则调用不起来
	{
		cout << "***********"<< endl;
	}
private:
	int& m_;
};
int main() //上述代码
{
	int num = 6;
	A a1(num);
	std::thread th(a1);//这里执行了拷贝构造函数
	//th.join();
	th.detach();
	cout << "main thread-------" << endl;
	return 0;
}

上述代码，可能有个疑问，一旦detach(), 那主线程结束了，则对象a1是否存在？
答案：这个对象实际是被【复制】到线程中去的，执行完主线程，a1确实会销毁，但复制的对象依然存在！
上述代码输出结果：
构造函数
拷贝构造函数
***********
析构函数--- //复制对象（线程的对象）
main thread-------
析构函数--- //主线程内a1对象

2）线程的参数使用

1）传递临时对象作为线程参数
//以下myprint函数中，主线程的buf地址和args地址是一个地址，当主线程detach的时候，会造成严重问题！所以绝对不能用指针
//修改为创建线程时，用string创建一个临时对象,在线程函数中，用string接这个临时对象就可以了；
//不用临时对象，则构造函数是在子线程进行的，是不安全的；用了临时对象，构造函数是在主函数执行的，所以是安全的。
//args要用引用来接，否则会再次调用一次拷贝构造函数，浪费！
//终极结论：尽可能用join，万不得已用detach;
void myprint(const int i, const string& args)  //char* args，这样写时错误的！
{
	cout << i << endl;
	cout << args.c_str() << endl;
	return;
}

int main() //上述代码
{
	int var = 1;
	int& varref = var;
	char buf[] = "i love china";
	//这里虽然是引用，但也是按值传递的【varref和参数i不是一个地址】，但老师也不建议这么写！！！
	std::thread th(myprint, varref, std::string(buf));  //直接写buf作为字符串参数也错误的，必须用创建临时对象作为参数；
	th.join();
	cout << "main thread------" << endl;
	return 0;
}

2)为什么要非得创建临时对象后，才可以作为线程参数，测试代码如下：
class A
{
public:
	A(int a) :a_(a) { cout << "a constructor--" << endl; }
	A(const A& obj) :a_(obj.a_) { cout << "a copy constructor--" << endl; }
	~A() { cout << "a deConstructor--" << endl; }
	int a_;
};

void printMsg(int i, const A& arg)
{
	cout << i << endl;
	cout << arg.a_ << endl;
}

int main()
{
	std::thread th(printMsg, 12, A(67));
	th.detach();
	cout << "main------thread" << endl;
	return 0;
}


2）传递类对象，智能指针作为线程参数
      用对象作为参数，在创建线程的时候，当子线程结束后，子线程的数据不会影响到主线程，因为都是按值传递的；
     如果真的想把子线程的数据返回给主线程，需要用std::ref()这个函数,才可以，这样子线程的计算数据会返回给主线程；
void printMsg(const A& arg) //这里为什么必须是const呢
{
	arg.a_ = 56;
	cout << arg.a_ << endl;
}

int main()
{
	A a1(3);
	std::thread th(printMsg, std::ref(a1)); //std::ref的用法
	th.join();
	cout << "main------thread a1.a_: "<<a1.a_ << endl;
	return 0;
}

//智能指针作为线程参数，注意事项：必须用join等待，用detach一定是错误的，因为ptr地址和arg地址是同一个地址!
void printMsg(std::unique_ptr<int> arg){}

int main()
{
	std::unique_ptr<int> ptr(new int(10));
	std::thread my(printMsg, std::move(ptr));
	my.join();
	return 0;
}

3）用vector创建多个线程，用容器管理线程

void func(int i) //线程入口函数
{
	cout << "thread is create,i is: " << i << endl;
}

int main()
{
	std::vector<std::thread> vth;
	for (int i = 0; i < 10; i++)
	{
		vth.push_back(std::thread(func, i)); //线程临时对象
	}
	for (auto iter = vth.begin(); iter != vth.end(); iter++)
	{
		iter->join();
	}
	cout << "main---------thread over" << endl;
	return 0;
}

4）创建多个线程，数据共享分析，共享数据的保护案例代码
4.1)直接使用互斥量

2)数据共享分析
2.1)只读数据：是安全稳定的，不需要特别处理手段！
2.2）又读又写：需要特殊处理，	最简单处理，能读时不能写，能写时不能读；
class A
{
public:
	//把收到的消息(玩家命令)插入到容器中的线程
	void inQueue()//成员函数入口
	{
		for (int i = 0; i < 10000; i++)
		{
			cout << "insert element " << i << endl;
			rlist.push_back(i);
		}
	}
	//从容器取出线程
	void outQueue()
	{
		for (int i = 0; i < 10000; i++)
		{
			if (!rlist.empty())
			{
				int cmd = rlist.front();//返回第一个元素，但不检查第一个元素是否存在
				rlist.pop_front();//移除第一个元素，但不返回
			}
			else
			{
				cout << "outQueue thread handle--but empty" << i << endl;
			}
		}
	}
private:
	std::list<int> rlist;//共享容器，代码玩家发过来的命令
};

int main()
{
	A obj;
	std::thread thOut(&A::outQueue, &obj);
	std::thread thin(&A::inQueue, &obj);
	thOut.join();
	thin.join();

	return 0;
}
上述代码运行时会出现错误，主要是两个线程（读线程和写线程）同时操作共享数据，造成的，如果解决，需要互斥量mutex;

4.2）std::mutex与std::lock_guard的配合使用

mtx.lock(); //如果锁成功，则返回；不成功，则一直等待
      std::lock_guard是类模板,如果使用了lock_guard, 就不能在使用mtx.lock和mtx.unlock; std::lock_guard<std::mutex> lock(mtx);
class A
{
public:
	//把收到的消息(玩家命令)插入到容器中的线程
	void inQueue()//成员函数入口
	{
		for (int i = 0; i < 10000; i++)
		{
			cout << "insert element " << i << endl;
			std::lock_guard<std::mutex> lock(mtx);
			//mtx.lock(); //如果锁成功，则返回；不成功，则一直等待
			rlist.push_back(i);
			//mtx.unlock();
		}
	}
	//从容器取出线程
	void outQueue()
	{
		for (int i = 0; i < 10000; i++)
		{
			if (!rlist.empty())
			{
				//mtx.lock();
				std::lock_guard<std::mutex> lock(mtx);
				//构造函数里执行了mtx.lock；
				int cmd = rlist.front();//返回第一个元素，但不检查第一个元素是否存在
				rlist.pop_front();//移除第一个元素，但不返回
				//mtx.unlock();
				//出作用域的时候，析构函数执行了mtx.unlock;
			}
			else
			{
				cout << "outQueue thread handle--but empty" << i << endl;
			}
		}
	}
private:
	std::list<int> rlist;//共享容器，代码玩家发过来的命令
	std::mutex mtx;
};

int main()
{
	A obj;
	std::thread thOut(&A::outQueue, &obj);
	std::thread thin(&A::inQueue, &obj);
	thOut.join();
	thin.join();
	cout << "main thread is over--------" << endl;

	return 0;
}

4.3)unique_lock代替lock_guard的使用

unique_lock取代lock_guard
  6.1)缺省值时，unique_lock和lock_guard是完全一样的用法；std::unique_lock<std::mutex> unique_guard1(mtx1);
        std::lock_guard<std::mutex> guard1(mtx1);
  6.2)unique_lock的第二参数；std::adopt_lock,std::defe_lock,std::try_to_lock等起到标记作用！！！注意没有括号,不是成员函数
      adopt_lock使用前提是提前加锁，defer_lock是不能提前加锁！调用unique_guard1.lock()手动加锁。
      unique_lock中，std::try_to_lock是尝试加锁，用owns_lock()这个成员函数做判断！
      unique_lock的成员函数：lock()，unlock();   try_lock()；（注意：try_lock()也要和defer_lock()一起使用);
      try_lock()函数用法和std::try_to_lock参数用法类似，只不过一个用成员函数实现，一个用参数实现。
      release()，返回mutex对象指针，并释放所有权。也就是说unique_lock和mutex不再有任何关系，如果原有对象mutex处于加锁状态，你有责任接管并解锁；
      相关的代码如下：
	std::unique_lock<std::mutex> uniqueGuard(mtx1);
	std::mutex* mtxptr = uniqueGuard.release();
	mtxptr->unlock();
6.3) unique_lock所有权的传递：
    通常情况下，unique_lock和mutex是配合实现的，类似于lock_gurard和mutex一样。
    std::unique_lock<std::mutex> uniqueGuard(mtx1);
    std::unique_lock<std::mutex> uniqueGuard2(std::move(uniqueGuard)); //把uniqueGuard的所有权转移到uniqueGuard2中，uniqueGuard为空;
    总结：数据保护说白了，就是何时lock，何时unlock，都有哪些使用方法；