本节讨论下在C++11中怎样使用std::async来执行异步task。
C++11中引入了std::async
什么是std::async
std::async()是一个接受回调(函数或函数对象)作为参数的函数模板，并有可能异步执行它们.
|
1
2
|
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的需求
假设我们必须从数据库和文件系统里里获取一些数据（字符串），然后需要合并字符串并打印。
在单线程中，我们这样做：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
#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()
|
1
2
3
|
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异步地从数据库中获取数据
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
#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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
/*
* 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
|
1
2
3
4
5
6
7
|
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多线程编程std::async内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://blog.csdn.net/lijinqi1987/article/details/78909479