什么是std::async

std::async()是一个接受回调(函数或函数对象)作为参数的函数模板，并有可能异步执行它们.

template<class Fn, class... Args>
future<typename result_of<Fn(Args...)>::type> async(launch policy, Fn&& fn, Args&&...args);

std::async返回一个std::future<T>，它存储由std::async()执行的函数对象返回的值。

函数期望的参数可以作为函数指针参数后面的参数传递给std::async()。

std::async中的第一个参数是启动策略，它控制std::async的异步行为，我们可以用三种不同的启动策略来创建std::async

·std::launch::async

保证异步行为，即传递函数将在单独的线程中执行

·std::launch::deferred

当其他线程调用get()来访问共享状态时，将调用非异步行为

·std::launch::async | std::launch::deferred

默认行为。有了这个启动策略，它可以异步运行或不运行，这取决于系统的负载，但我们无法控制它。

如果我们不指定一个启动策略，其行为将类似于std::launch::async | std::launch::deferred

本节我们将使用std::launch::async启动策略

我们可以在std::async传递任何回调，如：

·函数指针

·函数对象

·lambda表达式

 

​​为什么要用std::async​​

c++11中增加了线程，使得我们可以非常方便的创建线程，它的基本用法是这样的：

void f(int n);
std::thread t(f, n + 1);
t.join();

    但是线程毕竟是属于比较低层次的东西，有时候使用有些不便，比如我希望获取线程函数的返回结果的时候，我就不能直接通过 ​​thread.join()​​得到结果，这时就必须定义一个变量，在线程函数中去给这个变量赋值，然后​​join​​,最后得到结果，这个过程是比较繁琐的。

      c++11还提供了异步接口​​std::async​​，通过这个异步接口可以很方便的获取线程函数的执行结果。​​std::async​​会自动创建一个线程去调用 线程函数，它返回一个​​std::future​​，这个​​future​​中存储了线程函数返回的结果，当我们需要线程函数的结果时，直接从​​future​​中获取，非 常方便。

      但是我想说的是，其实​​std::async​​给我们提供的便利可不仅仅是这一点，它首先解耦了线程的创建和执行，使得我们可以在需要的时候获取异步 操作的结果；其次它还提供了线程的创建策略（比如可以通过延迟加载的方式去创建线程），使得我们可以以多种方式去创建线程。

在介绍​​async​​具体用法以及 为什么要用​​std::async​​代替线程的创建之前，我想先说一说​​std::future​​、​​std::promise​​和 ​​std::packaged_task​​。

 

std::future、std::promise和std::packaged_task

​​std::async​​是更高层次上的异步操作，使我们不用关注线程创建内部细节，就能方便的获取异步执行状态和结果，还可以指定线程创建策略，​​std::async​​是为了 让用户的少费点脑子的，它让这三个对象默契的工作。大概的工作过程是这样的：​​std::async​​先将异步操作用​​std::packaged_task​​包装起来，然后将异步操作的结果放到​​std::promise​​中，

下面介绍std::future、std::promise和std::packaged_task

std::future

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

​​deferred​​：异步操作还没开始
​​ready​​：异步操作已经完成
​​timeout​​：异步操作超时

//查询future的状态
std::future_status status;
do {
status = future.wait_for(std::chrono::seconds(1));
if (status == std::future_status::deferred) {
std::cout << "deferred\n";
        } else if (status == std::future_status::timeout) {
std::cout << "timeout\n";
        } else if (status == std::future_status::ready) {
std::cout << "ready!\n";
        }
    } while (status != std::future_status::ready);

获取​​future​​结果有三种方式：​​get​​、​​wait​​、​​wait_for​​，其中

get等待异步操作结束并返回结果，
wait只是等待异步操作完成，没有返回值，
wait_for是超时等待返回结果。

std::promise

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

std::promise<int> pr;
std::thread t([](std::promise<int> &p){p.set_value_at_thread_exit(9);}, std::ref(pr));
std::future<int> f = pr.get_future();
auto r = f.get();

std::packaged_task

​​std::packaged_task​​它包装了一个可调用的目标（如​​function​​, ​​lambda expression​​, ​​bind expression​​, or another ​​function 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();

std::promise、std::packaged_task和std::future的关系

至此, 我们介绍了​​std::async​​相关的几个对象​​std::future​​、​​std::promise​​和​​std::packaged_task​​，其中 ​​std::promise​​和​​std::packaged_task​​的结果最终都是通过其内部的​​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​​中。如果读者还没搞清楚他们的关系的话，我就用更通俗的话来解释一下。比如，一个小伙子给一个姑 娘表白真心的时候也许会说：”我许诺 会 给你一个美好的未来“或者”我会努力奋斗为你创造一个美好的未来“。姑娘往往会说：”我等着“。现在我来将这三句话用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中的许诺和未来是一定可靠的，发起来了许诺就一定有未来。细想起来c++11标准的制定者选定的关键字真是贴切而有 意思！好了，插科打诨到此了，现在言归正传，回过头来说说​​std::async​​。

 

为什么要用std::async代替线程的创建

​​std::async​​又是干啥的，已经有了​​std::future​​、​​std::promise​​和​​std::packaged_task​​，够多的 了，真的还要一个​​std::async​​来凑热闹吗，​​std::async​​表示很委屈：我不是来凑热闹的，我是来帮忙的。是的，​​std::async​​是为了 让用户的少费点脑子的，它让这三个对象默契的工作。大概的工作过程是这样的：​​std::async​​先将异步操作用​​std::packaged_task​​包装起来，然后将异步操作的结果放到​​std::promise​​中，这个过程就是创造未来的过程。外面再通过​​future.get/wait​​来获取这个未来的 结果，怎么样，​​std::async​​真的是来帮忙的吧，你不用再想到底该怎么用​​std::future、std::promise​​和​​std::packaged_task​​了，​​std::async​​已经帮你搞定一切了！

现在来看看​​std::async​​的原型​​async(std::launch::async | std::launch::deferred, f, args...)​​。

第一个参数是线程的创建策略，有两种策略，默认的策略是立即创建线程：

​​std::launch::async​​：在调用​​async​​就开始创建线程。
​​std::launch::deferred​​：延迟加载方式创建线程。调用​​async​​时不创建线程，直到调用了​​future​​的​​get​​或者​​wait​​时才创建线程。

第二个参数是线程函数，第三个参数是线程函数的参数。

std::async基本用法

函数返回int就future<int> ，没有返回就future<void> 

std::future<int> f1 = std::async(std::launch::async, [](){return 8;});
cout << f1.get() << endl; //output: 8

std::future<void> f2 = std::async(std::launch::async, [](){cout << 8 << endl;});
f2.wait(); //output: 8

std::future<int> future = std::async(std::launch::async, []()
{
std::this_thread::sleep_for(std::chrono::seconds(3));
return 8;
});

std::cout << "waiting...\n";
std::future_status status;
do
{
status = future.wait_for(std::chrono::seconds(1));
if (status == std::future_status::deferred)
    {
std::cout << "deferred\n";
    }
else if (status == std::future_status::timeout)
    {
std::cout << "timeout\n";
    }
else if (status == std::future_status::ready)
    {
std::cout << "ready!\n";
    }
}
while (status != std::future_status::ready);

std::cout << "result is " << future.get() << '\n';

可能的结果： waiting... timeout timeout ready! result is 8

总结：

​​std::async​​是更高层次上的异步操作，使我们不用关注线程创建内部细节，就能方便的获取异步执行状态和结果，还可以指定线程创建策略，应该用​​std::async​​替代线程的创建，让它成为我们做异步操作的首选。

std::async应用实例

std::async的需求

假设我们必须从数据库和文件系统里里获取一些数据（字符串），然后需要合并字符串并打印。

在单线程中，我们这样做：

#include <iostream>
#include <string>
#include <chrono>
#include <thread>

using namespace std::chrono;

std::string fetchDataFromDB(std::string recvData) {
//确保函数要5秒才能执行完成
std::this_thread::sleep_for(seconds(5));

//处理创建数据库连接、获取数据等事情
return "DB_" + recvData;
}

std::string fetchDataFromFile(std::string recvData) {
//确保函数要5秒才能执行完成
std::this_thread::sleep_for(seconds(5));

//处理获取文件数据
return "File_" + recvData;
}

int main() {
//获取开始时间
system_clock::time_point start = system_clock::now();

//从数据库获取数据
std::string dbData = fetchDataFromDB("Data");

//从文件获取数据
std::string fileData = fetchDataFromFile("Data");

//获取结束时间
auto end = system_clock::now();

auto diff = duration_cast<std::chrono::seconds>(end - start).count();
std::cout << "Total Time taken= " << diff << "Seconds" << std::endl;

//组装数据
std::string data = dbData +  " :: " + fileData;

//输出组装的数据
std::cout << "Data = " << data << std::endl;

return 0;
}

输出：

Total Time Taken  = 10 Seconds

Data = DB_Data :: File_Data

由于函数 fetchDataFromDB() 和 fetchDataFromFile()各自在单独的线程中运行5秒，所以，总共耗时10秒。

既然从数据库和文件系统中获取数据是独立的并且都要耗时，那我们可以并行地运行他们。

一种方式是创建一个新的线程传递一个promise作为线程函数的参数，并在调用线程中从关联的std::future对象获取数据

另一种方式就是使用std::async

使用函数指针调用std::async作为回调

修改上面的代码，并使用std::async异步调用fetchDataFromDB()

std::future<std::string>resultFromDB = std::async(std::launch::async, fetchDataFromDB, "Data");
std::string dbData = resultDromDB.get()

std::async()做如下的事情

·自动创建一个线程(或从内部线程池中挑选)和一个promise对象。

·然后将std::promise对象传递给线程函数，并返回相关的std::future对象

·当我们传递参数的函数退出时，它的值将被设置在这个promise对象中，所以最终的返回值将在std::future对象中可用

现在改变上面的例子，使用std::async异步地从数据库中获取数据

#include <iostream>
#include <string>
#include <chrono>
#include <thread>
#include <future>

using namespace std::chrono;

std::string fetchDataFromDB(std::string recvData) {
//确保函数要5秒才能执行完成
std::this_thread::sleep_for(seconds(5));

//处理创建数据库连接、获取数据等事情
return "DB_" + recvData;
}

std::string fetchDataFromFile(std::string recvData) {
//确保函数要5秒才能执行完成
std::this_thread::sleep_for(seconds(5));

//处理获取文件数据
return "File_" + recvData;
}

int main() {
//获取开始时间
system_clock::time_point start = system_clock::now();

std::future<std::string> resultFromDB = std::async(std::launch::async, fetchDataFromDB, "Data");

//从文件获取数据
std::string fileData = fetchDataFromFile("Data");

//从DB获取数据
//数据在future<std::string>对象中可获取之前，将一直阻塞
std::string dbData = resultFromDB.get();

//获取结束时间
auto end = system_clock::now();

auto diff = duration_cast<std::chrono::seconds>(end - start).count();
std::cout << "Total Time taken= " << diff << "Seconds" << std::endl;

//组装数据
std::string data = dbData +  " :: " + fileData;

//输出组装的数据
std::cout << "Data = " << data << std::endl;

return 0;
}

输出：

Total Time taken= 5Seconds

Data = DB_Data :: File_Data

只使用了5秒

用Function对象作为回调调用std::async

/*
* Function Object
*/
struct DataFetcher {
std::string operator ()(std::string recvdData) {
//确保函数要5秒才能执行完成
std::this_thread::sleep_for(seconds(5));
//处理获取文件数据
return "File_" + recvdData;

  }
};

 

//用函数对象调用std::async

std::future<std::string> fileResult = std::async(DataFetcher(), "Data"); 用lambda函数作为回调调用std::async

std::future<std::string> resultFromDB = std::async([](std::string recvdData) {

std::this_thread::sleep_for(seconds(5));
//处理创建数据库连接、获取数据等事情
return "DB_" + recvdData;

}, "Data");