一、std::async介绍
std::async用于创建异步任务，实际上就是创建一个线程异步执行相应任务，它接受回调（即函数或函数对象）作为参数。
std::async就是异步编程的高级封装，相当于封装了std::promise、std::packaged_task加上std::thread，基本上可以代替std::thread的所有事情。
template <class Fn, class... Args>
future<typename result_of<Fn(Args...)>::type> async (launch policy, Fn&& fn, Args&&... args);
std :: async返回一个std :: future ，该值存储由std :: async执行的函数对象返回的值。
std :: async中的第一个参数是启动策略，它控制std :: async的异步行为。我们可以使用 3 种不同的启动策略来创建，即：
std::launch::async：它保证了异步行为，即传递的函数将在单独的线程中执行。std::launch::deferred：非异步行为，即当其他线程将来调用 get() 以访问共享状态时，将调用 Function。std::launch::async | std::launch::deferred：它是默认行为。使用此启动策略，它可以异步运行或不异步运行，具体取决于系统上的负载。但是我们无法控制它。
二、案例分析
假设我们必须从数据库中获取一些数据（字符串），并从文件系统中的文件中获取一些数据。然后，我需要合并两个字符串并进行打印。
在单线程中，我们这样做：
#include <iostream>
#include <string>
#include <chrono>
#include <thread>
std::string fetchDataFromDB(std::string recvData) {
// 确保函数要5秒才能执行完成
std::this_thread::sleep_for(std::chrono::seconds(5));
// 处理创建数据库连接、获取数据等事情
return "DB_" + recvData;
}
std::string fetchDataFromFile(std::string recvData) {
// 确保函数要5秒才能执行完成
std::this_thread::sleep_for(std::chrono::seconds(5));
// 处理获取文件数据
return "File_" + recvData;
}
int main() {
// 获取开始时间
std::chrono::system_clock::time_point start = std::chrono::system_clock::now();
// 从数据库获取数据
std::string dbData = fetchDataFromDB("Data");
// 从文件获取数据
std::string fileData = fetchDataFromFile("Data");
// 获取结束时间
auto end = std::chrono::system_clock::now();
// 计算消耗时间
auto diff = std::chrono::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>
std::string fetchDataFromDB(std::string recvData) {
// 确保函数要5秒才能执行完成
std::this_thread::sleep_for(std::chrono::seconds(5));
// 处理创建数据库连接、获取数据等事情
return "DB_" + recvData;
}
std::string fetchDataFromFile(std::string recvData) {
// 确保函数要5秒才能执行完成
std::this_thread::sleep_for(std::chrono::seconds(5));
// 处理获取文件数据
return "File_" + recvData;
}
int main() {
//获取开始时间
std::chrono::system_clock::time_point start = std::chrono::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 = std::chrono::system_clock::now();
// 计算消耗时间
auto diff = std::chrono::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 = 5 Seconds
Data = DB_Data :: File_Data
*/
因为有一个任务是异步的，在 5 秒内可以同时执行完两个任务。
四、更多示例
std::async使用一个 callable 作为一个工作包。在本例中，它可以是个函数、函数对象或者匿名函数。
#include <future>
#include <iostream>
std::string helloFunction(const std::string& s) {
return "Hello C++11 from " + s + ".";
}
class HelloFunctionObject {
public:
std::string operator()(const std::string& s) const {
return "Hello C++11 from " + s + ".";
}
};
int main() {
// 带函数的future
auto futureFunction = std::async(helloFunction, "function");
// 带函数对象的future
HelloFunctionObject helloFunctionObject;
auto futureFunctionObject = std::async(helloFunctionObject, "function object");
// 带匿名函数的future
auto futureLambda = std::async([](const std::string& s) {return "Hello C++11 from " + s + "."; }, "lambda function");
std::cout << futureFunction.get() << "
"
<< futureFunctionObject.get() << "
"
<< futureLambda.get() << std::endl;
std::cout << std::endl;
}
/*
输出：
Hello C++11 from function.
Hello C++11 from function object.
Hello C++11 from lambda function.
*/
std::async调用在两端的 future 和 promise 创建了一个数据通道。通过 future 的 get() 调用，future 收到了它的工作包的返回值。
参考：
C++11 Multithreading – Part 9: std::async Tutorial & Example