std::async是什么?
std::async
是 C++11 引入的一个函数模板,用于启动异步任务。
它返回一个 std::future
对象,通过这个对象可以获取异步任务的结果。
std::async
可以让我们更方便地实现并行计算,提高程序的执行效率。
例子
std::async
的基本用法如下:
#include <iostream>
#include <future>
#include <thread>
// 一个简单的函数,用于演示异步任务
int add(int a, int b) {
std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时的任务
return a + b;
}
int main() {
// 使用 std::async 启动异步任务
// std::launch::async 指示启动策略,见后面的说明
// add, 5, 3 是要调用的函数及其参数
std::future<int> result = std::async(std::launch::async, add, 5, 3);
// 在等待结果的同时,可以做其他事情
std::cout << "Doing other work while waiting for the result..." << std::endl;
// 获取异步任务的结果, get() 会阻塞当前线程,直到异步任务完成并返回结果
int sum = result.get();
std::cout << "The sum is: " << sum << std::endl;
return 0;
}
这个简单的例子展示了如何使用 std::async 来执行异步任务,并在任务完成时获取结果。通过这种方式,可以更好地利用多核 CPU,提高程序的并行执行效率。
std::future<T>
std::async返回一个std::future<T>,它存储由std::async()执行的函数对象返回的值,例子中add返回的是int,所以 std::future<int> result =
启动策略
std::async中的第一个参数是启动策略,三种不同的启动策略:
·std::launch::async
保证异步行为,即传递函数将在单独的线程中执行
·std::launch::deferred
当其他线程调用get()来访问共享状态时,将调用非异步行为
·std::launch::async | std::launch::deferred
默认行为。有了这个启动策略,它可以异步运行或不运行,这取决于系统的负载,但我们无法控制它。
为什么要用std::async
c++11中增加了线程,使得我们可以非常方便的创建线程,它的基本用法是这样的:
void f(int n);
std::thread t(f, n + 1);
t.join();
1,获取返回结果不方便。
2,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
替代线程的创建,让它成为我们做异步操作的首选。
本文转自:http:///chengyuanchun/p/5394843.html
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");