[编程基础] C++多线程入门10-packaged_task示例
原始C++标准仅支持单线程编程。新的C++标准(称为C++11或C++0x)于2011年发布。在C++11中,引入了新的线程库。因此运行本文程序需要C++至少符合C++11标准。
10 packaged_task<>示例
在此示例中,我们将讨论c++11中std::packaged_task功能及其用法。std::packaged_task<>是一个类模板,代表一个异步任务。它封装了:
- 可调用实体,即函数,lambda函数或函数对象。
- 一种共享状态,用于存储由关联的回调返回或引发的异常的值。
需要std::packaged_task<>的情况
假设我们有一个现有函数,该函数从数据库中获取数据并返回
// Fetch some data from DB
std::string getDataFromDB(std::string token)
{
// Do some stuff to fetch the data
std::string data = "Data fetched from DB by Filter::" + token;
return data;
}
现在,我们要在单独的线程中执行此功能。但是,如何在其他线程完成之后将结果或异常取回主线程呢?
一种方法是更改函数的声明,并在函数中传递std::promise <>。在线程函数中传递std::promise <>对象之前,先从中获取关联的std::future <>并将其保留在主线程中。现在,在线程函数返回其值之前,应在传递的std::promise <>参数中设置该值,以便可以在主线程的关联std::future <>对象中使用它。具体可以见第八篇文章。
但是,如果我们使用std::packaged_task <>,则可以防止创建此std::promise <>和更改功能代码。
10.1 结合使用packaged_task <>和函数来创建异步任务
std::packaged_task <>可以包装普通函数,并使其可作为异步函数运行。在单独的线程中调用std:: packaged_task <>时,它将调用关联的回调并将返回值/异常存储在其内部共享状态中。可以通过std:: future <>对象在其他线程或主函数中访问此值。让我们从上述函数创建一个std::packaged_task <>,在单独的线程中执行,并从其future <>对象获取结果。
创建std::packaged_task <>对象
std::package_task <>是类模板,因此我们需要将模板参数传递给packaged_task <>,即可调用函数的类型
// Create a packaged_task<> that encapsulated the callback i.e. a function
std::packaged_task<std::string (std::string)> task(getDataFromDB);
从中获取future对象
// Fetch the associated future<> from packaged_task<>
std::future<std::string> result = task.get_future();
将packaged_task <>传递给线程
std::packaged_task <>是可移动的,但不可复制,因此我们需要将其移动到线程,即
// Pass the packaged_task to thread to run asynchronously
std::thread th(std::move(task), "Arg");
由于packaged_task仅可移动且不可复制,因此我们在将其移至线程之前从其获取了std::future <>对象。线程将执行此任务,该任务在内部调用关联的可调用实体,即我们的函数getDataFromDB()。
现在,当此函数返回值时,std::packaged_task <>会将其设置为关联的共享状态,并且getDataFromDB()返回的结果或异常最终将在关联的future对象中可用。
在主函数中,从future <>对象获取结果,即
// Fetch the result of packaged_task<> i.e. value returned by getDataFromDB()
std::string data = result.get();
get()函数将阻塞调用线程,直到可调用实体返回并且std::packaged_task <>将数据设置为可共享状态为止。完整的示例代码如下:
#include <iostream>
#include <thread>
#include <future>
#include <string>
// Fetch some data from DB
std::string getDataFromDB(std::string token)
{
// Do some stuff to fetch the data
std::string data = "Data fetched from DB by Filter::" + token;
return data;
}
int main()
{
// Create a packaged_task<> that encapsulated the callback i.e. a function
// 创建封装回调函数的packaged_task<>
std::packaged_task<std::string(std::string)> task(getDataFromDB);
// Fetch the associated future<> from packaged_task<>
// 从packaged_task<>中获取关联的future<>对象
std::future<std::string> result = task.get_future();
// Pass the packaged_task to thread to run asynchronously
// 将packaged_task传递给线程以异步运行
std::thread th(std::move(task), "Arg");
// Join the thread. Its blocking and returns when thread is finished.
// 加入线程,完成后返回
th.join();
// Fetch the result of packaged_task<> i.e. value returned by getDataFromDB()
// 获取packaged_task<> 的结果,即getDataFromDB()返回的值
std::string data = result.get();
std::cout << data << std::endl;
return 0;
}
输出为:
Data fetched from DB by Filter::Arg
在类似的行中,我们可以创建一个包含lambda函数和函数对象的packaged_task <>,如下所示:
使用Lambda函数创建packaged_task
#include <iostream>
#include <thread>
#include <future>
#include <string>
int main()
{
// Create a packaged_task<> that encapsulated a lambda function
std::packaged_task<std::string(std::string)> task([](std::string token) {
// Do some stuff to fetch the data
std::string data = "Data From " + token;
return data;
});
// Fetch the associated future<> from packaged_task<>
std::future<std::string> result = task.get_future();
// Pass the packaged_task to thread to run asynchronously
std::thread th(std::move(task), "Arg");
// Join the thread. Its blocking and returns when thread is finished.
th.join();
// Fetch the result of packaged_task<> i.e. value returned by getDataFromDB()
std::string data = result.get();
std::cout << data << std::endl;
return 0;
}
输出为:
Data From Arg
使用函数对象创建packaged_task
#include <iostream>
#include <thread>
#include <future>
#include <string>
/*
* Function Object to Fetch Data from DB
*/
struct DBDataFetcher
{
std::string operator()(std::string token)
{
// Do some stuff to fetch the data
std::string data = "Data From " + token;
return data;
}
};
int main()
{
// Create a packaged_task<> that encapsulated a lambda function
std::packaged_task<std::string(std::string)> task(std::move(DBDataFetcher()));
// Fetch the associated future<> from packaged_task<>
std::future<std::string> result = task.get_future();
// Pass the packaged_task to thread to run asynchronously
std::thread th(std::move(task), "Arg");
// Join the thread. Its blocking and returns when thread is finished.
th.join();
// Fetch the result of packaged_task<> i.e. value returned by getDataFromDB()
std::string data = result.get();
std::cout << data << std::endl;
return 0;
}
输出为:
Data From Arg
10.2 参考
https://thispointer.com/c11-multithreading-part-10-packaged_task-example-and-tutorial/
本文来自博客园,作者:落痕的寒假,转载请注明原文链接:https://www.cnblogs.com/luohenyueji/p/16970262.html
![](https://gitcode.net/LuohenYJ/article_picture_warehouse/-/raw/main/wechat/content/%E5%8A%A0%E6%B2%B9%E9%B8%AD.gif)