C++11的多线程并发编程（五）

C++11的多线程并发编程（五）

疫情确诊人数连续12天下降，终将结束，然鹅还是处于不能出门状态，继续记笔记吧。。。

1. 条件变量 condition_variable
   假设有两个线程就是前篇记录的放队列数据线程，和读队列数据线程，条件变量就是一个条件类，等待一个条件达成即执行代码。执行成员函数wait（）等待另一个线程执行notify_one（）的成员函数。那么wait（）这行代码才会被唤醒，如下：

#include <iostream>
#include <thread>
#include <list>
#include <mutex>

using namespace std;

class A
{
public:
	void inCommand()
	{
		for(int i = 0; i < 1000; i++)
		{
			lock_guard<mutex> myguard1(mylock);
			ticket.push_back(i);
			mycond.notify_one();
			cout << "a command is comming" << endl;
		}
	}
	
	void outCommand()
	{
		for(int j = 0; j < 1000; j++)
		{
			unique_lock<mutex> myguard1(mylock);
			
			mycond.wait(myguard1,[this]{
				if(!ticket.empty())
					return true;
				return false;
			});
			int command = ticket.front();
			ticket.pop_front();	
			cout << "command is :" << command << endl;
		}
		
	}
	
private:
	list<int> ticket;
	mutex mylock;
	condition_variable mycond;
	
};

int main(int argc, char *argv[])
{
	A a;
	thread thread1(&A::inCommand, &a);
	thread thread2(&A::outCommand, &a);
	thread1.join();
	thread2.join();

	cout << "the main thread is end;" << endl;
	return 0;
}

当写线程执行notify_one()代码时，将原本wait的代码唤醒，wait就开始执行，
首先去获取锁，如果没有就等待，有的话，开始判断lambda表达式，如果返回false那就释放锁，继续等待，如果返回的是true,那么就继续往下执行下面代码。
当有多个线程需要读取这个命令是什么去执行其他操作，那就可以令写进程执行mycond.notify_all();去通知所有读进程去唤醒wait（).

2. async
   async是一个函数模板，通常是启动一个异步任务，即创建一个线程，并执行对应的线程入口函数，返回一个future对象。future是一个类模板，那么我创建一个它的对象去接async异步任务返回的对象，再去调用成员函数get()即可以获得函数返回值。

future就是一种访问异步操作结果的类。里面会保存一个值，在线程入口函数执行结束时就会拿到这个值。用法如下：

#include <iostream>
#include <thread>
#include <future>
using namespace std;
int myFunc()
{
	cout << "this is thread" << endl;
	return 99;
}
int main()
{
	future<int> myfuture = async(myFunc);
	cout << myfuture.get() << endl;  //处于等待中，线程执行完毕就往下执行
	return 0;
}

async参数默认是std::launch::async,在调用async函数的时候就开始创建线程了，还有一个参数是std::launch::deferred，表示延迟调用，并不会创建新的线程。

3. std::packaged_task
   这个是类模板，将可调用对象包装起来，然后作为线程入口函数使用。使用方法如图所示：

#include <iostream>
#include <thread>
#include <future>
using namespace std;
int myFunc(int value)
{
	cout << value << endl;
	return 99;
}
int main()
{
	packaged_task<int(int) myPackage(myFunc);//一个是int返回值，一个是int参数
	thread myThread(std::ref(mypackage),100); //因为packaged_task是一个类模板，所以保证是同一个对象，采用移动语义。
	myThread.join();
	
	future<int> myFuture = myPackage.get_future(); 
	cout << myFuture.get() << endl;
	return 0;
	
}

也可以使用向量vector来操作，例如：

vector <packaged_task<int(int)>> myTask;
package_task<int(int)> myPackage(myFunc);
myTask.push_back(move(myPackage));//此时myPackage已经失效了
package_task<int(int)> myPackage2;
auto iter = myTask.begin();
myPackage2 = move(*iter);
myTask.erase(iter); //iter已经失效了该删除了
myPackage2(99);
future <int> myfuture = myPackage2.get_future();
cout << myfuture.get() << endl;

或者使用lambda表达式来解决

	packaged_task<int(int) myPackage([](int value){
		cout << value << endl;
		return 99;
	});//一个是int返回值，一个是int参数
	thread myThread(std::ref(mypackage),100); //因为packaged_task是一个类模板，所以保证是同一个对象，采用移动语义。
	myThread.join();
	
	future<int> myFuture = myPackage.get_future(); 
	cout << myFuture.get() << endl;
	return 0;

效果等价于上方

4. std::promise
   这也是一个类模板，如果在一个线程中给他赋值，那么我们可以在另外一个线程中将他取出来用。使用方法如下：

#include <iostream>
#include <thread>
#include <future>

void myFunc1(std::promise &myPromise, int value)
{
	myPromise.set_value(value);
	return ;
}
void myFunc2(std::future<int> &myFuture)
{
	auto myValue = myFuture.get();
	cout << myValue << endl;
}

int main()
{
	promise<int> myPromise;
	thread myThread1(myFunc1, ref(myPromise),100);
	myThread1.join();

	future<int> myFuture = myPromise.get_future();
	thread myThread2(myFunc2, ref(myFuture));
	myThread2.join();
	//int result = myFuture.get();//就是获取值的代码在另外一个线程实现了
	return 0;
}

5. future目前执行状态
   future_status status有三种状态，一种是timeout 表示还没有执行完，一种是ready就表示已经执行完了，还有一种是deferred，这种情况下一般用在使用async函数，同时第一个参数被设置为launch::deferred，当status表示deferred表示目前线程处于延迟状态。

6. shared_future
   当在另外一个线程执行get()获取future存的值，如果再次执行get()则会报异常，因为get函数同时也表示移动的意思，shared_future用来解决这个问题：代码图下：

#include <iostream>
#include <thread>
#include <future>

void myFunc1(std::promise &myPromise, int value)
{
	myPromise.set_value(value);
	return ;
}
void myFunc2(std::shared_future<int> &myFuture)
{
	auto myValue = myFuture.get();
	cout << myValue << endl;
}

int main()
{
	promise<int> myPromise;
	thread myThread1(myFunc1, ref(myPromise),100);
	myThread1.join();

	future<int> myFuture = myPromise.get_future();

	shared_future<int> myshareFuture(myFuture.share());
	int shareResult = myshareFuture.get();
	thread myThread2(myFunc2, ref(shareResult));
	myThread2.join();
	//int result = myFuture.get();//就是获取值的代码在另外一个线程实现了
	return 0;
}```