原文链接：std::async介绍与实例，用C++11的std::async代替线程的创建
- 什么是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::launch::async：在调用async就开始创建线程。
- std::launch::deferred：延迟加载方式创建线程。调用async时不创建线程，直到调用了future的get或者wait时才创建线程。
- 第二个参数是线程函数
- 第三个参数是线程函数的参数
- 默认行为。有了这个启动策略，它可以异步运行或不运行，这取决于系统的负载，但我们无法控制它。
- 如果我们不指定一个启动策略，其行为将类似于std::launch::async | std::launch::deferred
- 假设我们必须从数据库和文件系统里里获取一些数据（字符串），然后需要合并字符串并打印。
- 在单线程中，我们这样做：
#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
用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");附：用C++11的std::async代替线程的创建
c++11中增加了线程，使得我们可以非常方便的创建线程，它的基本用法是这样的：
void f(int n);
std::thread t(f, n + 1);
t.join()- 但是线程毕竟是属于比较低层次的东西，有时候使用有些不便，比如希望获取线程函数的返回结果的时候，就不能直接通过thread.join()得到结果。在POSIX线程函数中，这时候就必须定义一个变量，在线程函数中去给这个变量赋值，然后在线程函数中返回这个变量或调用pthread_exit()函数时以此变量的指针的地址为参数，然后在主线程中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::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是超时等待返回结果。
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::async代替线程的创建
- std::async是来帮忙的，帮忙封装，让以上三个对象默契地工作。大致的工作过程如下：
- std::async先将异步操作用std::packaged_task包装起来，然后将异步操作的结果放到std::promise中，这个过程就是创造未来的过程；外面再通过future.get/wait来获取这个未来的结果。
- 不用再想到底该怎么用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时才创建线程。
- 第二个参数是线程函数
- 第三个参数是线程函数的参数
#include <future>
#include <iostream>
int main()
{
std::future<int> f1 = std::async(std::launch::async, [](){ return 8; });
std::cout << f1.get() << std::endl; //output: 8
std::future<void> f2 = std::async(std::launch::async, [](){ std::cout << 8 << std::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() << std::endl;
}- 可能的结果：
8
8
waiting...
timeout
timeout
ready!
result is 8- 总结：std::async是更高层次上的异步操作，使我们不用关注线程创建内部细节，就能方便的获取异步执行状态和结果，还可以指定线程创建策略，应该用std::async替代线程的创建，让它成为我们做异步操作的首选。
906
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
