C++11异步操作

C++ 11 提供了异步操作相关的类,主要有std::future std::promise std::package_task

std::future作为异步结果的传输通道,获取线程函数的返回值;

std::promise用来包装一个值,将数据和std::future绑定;

std::package用来包装一个对象,将数据和future绑定起来,以方便异步调用;

`std::future`

future提供了异步查询的通道,我们可以用同步等待的方式来获取结果,可以通过查询future的状态(future_status)来获取异步操作的结果

enum class future_status {
    ready,   //异步操作已经完成
    timeout, //异步操作超时
    deferred //异步操作还没开始
};

我们可以不断查询future的状态,并比对,直到任务完成为止

`std::promise`

std::promise将数据和future绑定,为获取线程中的某个值提供便利

在线程函数中为promise赋值
在线程函数执行完毕后就可以通过promise的future获取值

示例:

#include<iostream>
#include <string>
#include <tuple>
#include <mutex>
#include <thread>
#include <list>
#include <condition_variable>
#include <future>
using namespace std;
std::promise<int> pr;

void set_value(int i)
{
	std::this_thread::sleep_for(std::chrono::seconds(3));
	pr.set_value_at_thread_exit(i);
}

int main()
{
	std::thread t1(set_value, 90);
	t1.join();
	std::future<int> f = pr.get_future();
	cout << f.get() << endl;
}

`std::package_task`

std::package_task包装了一个可调用对象的包装类(function ,lambda function ,bind expression…)

将函数和future绑定起来,以便异步调用

示例:

#include<iostream>
#include <string>
#include <tuple>
#include <mutex>
#include <thread>
#include <list>
#include <condition_variable>
#include <future>
#include <functional>
using namespace std;

int return_value(int i )
{
	cout << i << endl;
	return i * 10;
}
int main()
{
	std::packaged_task<int(int)> task(return_value);
	std::future<int> f = task.get_future();

	std::thread t(std::ref(task),4);
	t.join();
	int result = f.get();
	cout << result << endl;	
}

std::future``std::promise``std::package_task之间区别

std::future提供了一个访问异步操作结果的机制，它和线程是一个级别的，属于低层次的对象。在std::future之上的高一层是std:packaged_task和std::promise,它们内部都有future 以便访问异步操作结果，std::packaged_task包装的是一个异步操作，而std:;promise包装的是一个值，都是为了方便异步操作，因为有时需要获取线程中的某个值，这时就用std:promise,而有时需要获一个异步操作的返回值，这时就用std:packaged_task。那么std:promise和std:packaged_task之间又是什么关系呢?可以将一个异步操作的结果保存到std::promise中。future被promise和package_task用来作为异步操作或者异步结果的连接通道，用std::future和std:.shared_future来获取异步调用的结果。future是不可拷贝的，只能移动，shared_future是可以拷贝的，当需要将future放到容器中则需要用shared_future,
package_task和 shared_future的基本用法如下:

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

#include <condition_variable>
#include <future>
#include <functional>
using namespace std;


int func(int x)
{
	return x + 1;
}

int main()
{
	
	std::packaged_task<int(int)> task(func);
	std::future<int> fut = task.get_future();

	std::thread(std::move(task), 2).detach();
	int value = fut.get();
	cout << value << endl;

	vector<std::shared_future<int >> v;
	std::shared_future<int> f = std::async(std::launch::async, [](int a, int b) {return a + b; }, 2, 3);

	v.push_back(f);
	std::cout << v[0].get() << endl;

}