c++多线程之std::async_c++ 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);
1
2

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

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

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

·函数指针
·函数对象
·lambda表达式

二、std::async()做什么

·自动创建一个线程(或从内部线程池中挑选)和一个promise对象。
·然后将std::promise对象传递给线程函数，并返回相关的std::future对象
·当我们传递参数的函数退出时，它的值将被设置在这个promise对象中，所以最终的返回值 将在std::future对象中可用

所以std::async()组合了std::future与std::promise

三、示例
假设我们必须从数据库和文件系统里里获取一些数据（字符串），然后需要合并字符串并打印。
1、用单线程时

#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;
}
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

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

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

using namespace std::chrono;
using namespace std;

string fetchDataFromDB(string recvData)
{
	std::this_thread::sleep_for(std::chrono::seconds(5));
	return "DB_" + recvData;
}
string fetchDataFromFile(string recvData)
{
	std::this_thread::sleep_for(std::chrono::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");
	
//	string dbData = fetchDataFromDB("Data");
	string fileData = fetchDataFromFile("Data");

//数据在future<std::string>对象中可获取之前，将一直阻塞
	string dbData = resultFromDB.get();
	system_clock::time_point end = system_clock::now();
	auto diff = duration_cast<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;

	system("pause");
	return 0;
}
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

3、用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"); 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4、用lambda函数作为回调调用std::async

std::future<std::string> resultFromDB = std::async([](std::string recvdData) {
 
  std::this_thread::sleep_for(seconds(5));
  //处理创建数据库连接、获取数据等事情
  return "DB_" + recvdData;
 
}, "Data"); 
1
2
3
4
5
6
7