async future

7.std::async

我们已经有多线程thread了，为什么还要有async?
线程毕竟是属于比较低层次的东西，有时候使用有些不便，比如我希望获取线程函数的返回结果的时候，我就不能直接通过  thread.join()得到结果，这时就必须定义一个变量，在线程函数中去给这个变量赋值，然后 join,最后得到结果，这个过程是比较繁琐的。
c++11还提供了异步接口 std::async，通过这个异步接口可以很方便的获取线程函数的执行结果。 std::async会自动创建一个线程去调用 线程函数，它返回一个 std::future，这个 future中存储了线程函数返回的结果，当我们需要线程函数的结果时，直接从 future中获取非常方便。
std::async是更高层次上的异步操作，使我们不用关注线程创建内部细节，就能方便的获取异步执行状态和结果，还可以指定线程创建策略， std::async是为了 让用户的少费点脑子的，它让这三个对象默契的工作。大概的工作过程是这样的：std::async先将异步操作用std::packaged_task包装起来，然后将异步操作的结果放到std::promise中，

7.1 理解

1. std::async是用来创建异步任务的。

2. std::async有两个参数：std::launch::deferred和 std::launch::async

7.2 异同

1，std::async()与std::thread()最明显的不同，就是async并不一定创建新的线程

2，std::thread() 如果系统资源紧张，那么可能创建线程失败，整个程序可能崩溃。

3，std::thread()创建线程的方式，如果线程返回值，你想拿到这个值也不容易；

4，std::async()创建异步任务，可能创建也可能不创建线程；并且async调用方式很容易拿到线程入口函数的返回值。

7.3 参数

1，参数std::launch::deferred 延迟调用；参数std::launch::async 强制创建一个新线程

2，如果你用std::launch::deferred来调用async会怎么样？std::launch::deferred延迟调用，延迟到future对象调用get()或者wait()的时候才执行mythread();如果不调用get()或者wait()，mythread()不会执行。

3，std::launch::async：强制这个异步任务在新线程上执行，这意味着，系统必须要给我创建出新线程来运行mythread();

4，std::launch::async |std::launch::deferred 这里这个 |：以为这调用async的行为可能是 创建新线程并立即执行，或者没有创建新线程并且延迟调用result.get()才开始执行任务入口函数，两者居其一。

5，不带额外参数；只给一个入口函数名；默认是应该是std::launch::async |std::launch::deferred，和c)效果一致，换句话说，系统会自行决定是异步（创建新线程）还是同步（不创建新线程）方式运行

7.4 注意

由于系统资源限制：

（1）如果使用std::thread()创建的线程太多，则可能创建线程失败，系统报告异常，崩溃；
（2）如果用std::async,一般就不会报异常崩溃，因为如果系统资源紧张导致无法创建新线程的时候，std::async这种不加额外参数的调用就不会创建新线程，而是后续谁调用了future::get()来请求结果，那么这个异步任务就运行在执行这条get()语句所在的线程上。
（3）如果你强制std::async创建新线程，那么就必须使用std::launch::async，承受的代价就是系统资源紧张时，可能程序崩溃。经验：一个程序里，线程的数量不易超过100-200，与时间片有关，详情参考操作系统。

7.5 async不确定性问题的解决

不加额外参数的std::async调用问题，让系统自行决定是否创建新的线程。

问题的焦点在于 std::future<int> result = std::async(mythread)写法，这个异步任务到底 有没有被推迟执行。

解决代码：

#include<iostream>
#include<thread>
#include<string>
#include<vector>
#include<list>
#include<mutex>
#include<future>
using namespace std;
 
int mythread() //线程入口函数
{
	cout << "mythread start" << "threadid= " << std::this_thread::get_id() << endl; //打印线程id
 
	std::chrono::milliseconds dura(5000); //定一个5秒的时间
	std::this_thread::sleep_for(dura);  //休息一定时常
 
	cout << "mythread end" << "threadid= " << std::this_thread::get_id() << endl; //打印线程id
 
	return 5;
}
int main()
{
	cout << "main" << "threadid= " << std::this_thread::get_id() << endl;
	std::future<int> result = std::async(mythread);//流程并不卡在这里
	cout << "continue....." << endl;
 
	//枚举类型
	std::future_status status = result.wait_for(std::chrono::seconds(0));//等待一秒
	
	if (status == std::future_status::deferred)
	{
		//线程被延迟执行了，系统资源紧张
		cout << result.get() << endl; //此时采取调用mythread()
	}
	else if (status == std::future_status::timeout)//
	{
		//超时：表示线程还没执行完；我想等待你1秒，希望你返回，你没有返回，那么 status = timeout
		//线程还没执行完
		cout << "超时：表示线程还没执行完!" << endl;
	}
	else if (status == std::future_status::ready)
	{
		//表示线程成功返回
		cout << "线程成功执行完毕，返回!" << endl;
		cout << result.get() << endl;
	}
 
	cout << "I love China!" << endl;
	return 0;
}

7.6使用

// C++ Standard: C++17
#include <iostream>
#include <thread>
#include <future>
using namespace std;
int main() {
	async(launch::async, [](const char *message){
		cout << message << flush;
	}, "Hello, ");
	cout << "World!" << endl;
	return 0;
}

8.std::future

std::future是一个非常有用也很有意思的东西，简单说 std::future提供了一种访问异步操作结果的机制。从字面意思来理解， 它表示未来，我觉得这个名字非常贴切，因为一个异步操作我们是不可能马上就获取操作结果的，只能在未来某个时候获取，但是我们可以同步等待的方式来获取 结果，可以通过查询 future的状态（ future_status）来获取异步操作的结果。

我们想要从线程中返回异步任务结果，一般需要依靠全局变量；从安全角度看，有些不妥；为此C++11提供了std::future类模板，future对象提供访问异步操作结果的机制，很轻松解决从异步任务中返回结果.

在C++标准库中，有两种“期望”，使用两种类型模板实现:

唯一期望(unique futures，std::future<>) std::future的实例只能与一个指定事件相关联。

共享期望(shared futures)(std::shared_future<>) std::shared_future的实例就能关联多个事件。

对于future补充说明如下：
std::async 、 std::packaged_task 或 std::promise 能提供一个std::future对象给该异步操作的创建者
异步操作的创建者能用各种方法查询、等待或从 std::future 提取值。若异步操作仍未提供值，则这些方法可能阻塞。
异步操作准备好发送结果给创建者时，它能通过接口（eg,std::promise::set_value std::future） 修改共享状态的值。

常用函数：

时序图：

使用：

//通过async来获取异步操作结果
std::future<int>  result = std::async([](){ 
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    return 8; 
});

std::cout << "the future result : " << result.get() << std::endl;
std::cout << "the future status : " << result.valid() << std::endl;
try
{
    result.wait();  //或者 result.get() ,会异常
  //因此std::future只能用于单线程中调用 ，多线程调用使用std::share_future();
}
catch (...)
{
    std::cout << "get error....\n ";
}

9.std::promise

std::promise为获取线程函数中的某个值提供便利， 在线程函数中给外面传进来的promise赋值，当线程函数执行完成之后就可以通过 promise获取该值了，值得注意的是取值是间接的通过 promise内部提供的 future来获取的。

promise实际上是std::future的一个包装，在讲解future时，我们并没有牵扯到改变future值的问题，但是如果使用thread以引用传递返回值的话，就必须要改变future的值，那么该怎么办呢？实际上，future的值不能被改变，但你可以通过promise来创建一个拥有特定值的future。

future的值不能改变，promise的值可以改变。

常用成员函数：

使用：

// Compiler: MSVC 19.29.30038.1
// C++ Standard: C++17
#include <iostream>
#include <thread>
#include <future> // std::promise std::future
using namespace std;

template<class ... Args> decltype(auto) sum(Args&&... args) {
	return (0 + ... + args);
}

template<class ... Args> void sum_thread(promise<long long> &val, Args&&... args) {
	val.set_value(sum(args...));
}

int main() {
	promise<long long> sum_value;
	thread get_sum(sum_thread<int, int, int>, ref(sum_value), 1, 10, 100);
	cout << sum_value.get_future().get() << endl;
	get_sum.join(); 
	return 0;
}

10.std::packaged_task

std::packaged_task它包装了一个可调用的目标（如function,lambda expression,bind expression, or anotherfunction object）,以便异步调用，它和promise在某种程度上有点像，promise保存了一个共享状态的值，而packaged_task保存的是一 个函数。它的基本用法：

std::packaged_task<int()> task([](){return 7;});
std::thread t1(std::ref(task));
std::future<int> f1 = task.get_future();
auto r1 = f1.get();

如果读者还没搞清楚他们的关系的话，我就用更通俗的话来解释一下。比如，一个小伙子给一个姑 娘表白真心的时候也许会说：”我许诺 会 给你一个美好的未来“或者”我会努力奋斗为你创造一个美好的未来“。姑娘往往会说：”我等着“。现在我来将这三句话用c++11来翻译一下：

小伙子说：我许诺会给你一个美好的未来等于c++11中"std::promise a std::future";
小伙子说：我会努力奋斗为你创造一个美好的未来等于c++11中"std::packaged_task a future";
姑娘说：我等着等于c++11中"future.get()/wait()";

小伙子两句话种有个中差异，自己琢磨一下，这点差异也是std::promise和std::packaged_task的差异。现实中的山盟海 誓靠不靠得住我不知道，但是c++11中的许诺和未来是一定可靠的，发起来了许诺就一定有未来简单实现

参考文章：https://www.cnblogs.com/bandaoyu/p/