C++11中std::packaged_task的使用详解

2023-08-02 10:21:03 71

C++11中的std::packaged_task是个模板类。std::packaged_task包装任何可调用目标(函数、lambda表达式、bind表达式、函数对象)以便它可以被异步调用。它的返回值或抛出的异常被存储于能通过std::future对象访问的共享状态中。

std::packaged_task类似于std::function，但是会自动将其结果传递给std::future对象。

std::packaged_task对象内部包含两个元素：(1).存储的任务(storedtask)是一些可调用的对象(例如函数指针、成员或函数对象的指针)(Astoredtask,whichissomecallableobject(suchasafunctionpointer,pointertomemberorfunctionobject))。(2).共享状态，它可以存储调用存储的任务(storedtask)的结果，并可以通过std::future进行异步访问(Asharedstate,whichisabletostoretheresultsofcallingthestoredtaskandbeaccessedasynchronouslythroughafuture)。

通过调用std::packaged_task的get_future成员将共享状态与std::future对象关联。调用之后，两个对象共享相同的共享状态：(1).std::packaged_task对象是异步提供程序(asynchronousprovider)，应通过调用存储的任务(storedtask)在某个时刻将共享状态设置为就绪。(2).std::future对象是一个异步返回对象，可以检索共享状态的值，并在必要时等待其准备就绪。

共享状态的生存期至少要持续到与之关联的最后一个对象释放或销毁为止。

std::packaged_task不会自己启动，你必须调用它(Apackaged_taskwon'tstartonit'sown,youhavetoinvokeit)。

std::future介绍参考：https://www.nhooo.com/article/179229.htm

模板类std::packaged_task成员函数包括：

1.构造函数：(1).默认构造函数：无共享状态无存储任务(nosharedstateandnostoredtask)情况下初始化对象。(2).initializationconstructor：该对象具有共享状态，且其存储的任务由fn初始化。(3).initializationconstructorwithallocator。(4).禁用拷贝构造。(5).支持移动构造。

2.析构函数：(1).放弃(abandon)共享状态并销毁packaged_task对象。(2).如果有其它future对象关联到同一共享状态，则共享状态本身不会被销毁。(3).如果packaged_task对象在共享状态准备就绪前被销毁，则共享状态自动准备就绪并包含一个std::future_error类型的异常。

3.get_future函数：(1).返回一个与packaged_task对象的共享状态关联的std::future对象。(2).一旦存储的任务被调用，返回的std::future对象就可以访问packaged_task对象在共享状态上设置的值或异常。(3).每个packaged_task共享状态只能被一个std::future对象检索(Onlyonefutureobjectcanberetrievedforeachpackaged_tasksharedstate)。(4).调用此函数后，packaged_task应在某个时候使其共享状态准备就绪(通过调用其存储的任务)，否则将在销毁后自动准备就绪并包含一个std::future_error类型的异常。

4.make_ready_at_thread_exit函数：在线程退出时才使共享状态ready而不是在调用完成后就立即ready。

5.operator=：(1).禁用拷贝赋值。(2).支持移动赋值。

6.operator()：(1).callstoredtask。(2).如果对存储任务的调用成功完成或抛出异常，则返回的值或捕获的异常存储在共享状态，共享状态准备就绪(解除阻塞当前等待它的所有线程)。

7.reset函数：(1).在保持相同存储的任务的同时，以新的共享状态重置对象。(2).允许再次调用存储的任务。(3).与对象关联的之前的共享状态被放弃(就像packaged_task被销毁了一样)。(4).在内部，该函数的行为就像是移动赋值了一个新构造的packaged_task一样(Internally,thefunctionbehavesasifmove-assignedanewlyconstructedpackaged_task(withitsstoredtaskasargument))。

8.swap函数/非成员模板函数swap：交换共享状态和存储的任务(storedtask)。

9.valid函数：检查packaged_task对象是否具有共享状态。

详细用法见下面的测试代码，下面是从其他文章中copy的测试代码，部分作了调整，详细内容介绍可以参考对应的reference：

#include"future.hpp"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

namespacefuture_{

///////////////////////////////////////////////////////////
//reference:http://www.cplusplus.com/reference/future/packaged_task/
inttest_packaged_task_1()
{

{//constructor/get_future/operator=/valid
std::packaged_taskfoo;//default-constructed
std::packaged_taskbar([](intx){returnx*2;});//initialized

foo=std::move(bar);//move-assignment
std::cout<<"valid:"<ret=foo.get_future();//getfuture
std::thread(std::move(foo),10).detach();//spawnthreadandcalltask

intvalue=ret.get();//waitforthetasktofinishandgetresult
std::cout<<"Thedoubleof10is"<tsk([](intx){returnx*3;});//packagetask

std::futurefut=tsk.get_future();
tsk(33);
std::cout<<"Thetripleof33is"<tsk(countdown);//setuppackaged_task
std::futureret=tsk.get_future();//getfuture

std::threadth(std::move(tsk),5,0);//spawnthreadtocountdownfrom5to0

intvalue=ret.get();//waitforthetasktofinishandgetresult
std::cout<<"Thecountdownlastedfor"<task([](inta,intb){returnstd::pow(a,b);});
std::futureresult=task.get_future();

task(2,9);
std::cout<<"task_lambda:\t"<task(std::bind([](intx,inty){returnstd::pow(x,y);},2,11));
std::futureresult=task.get_future();

task();
std::cout<<"task_bind:\t"<task([](intx,inty){returnstd::pow(x,y);});
std::futureresult=task.get_future();

std::threadtask_td(std::move(task),2,10);
task_td.join();
std::cout<<"task_thread:\t"<thatencapsulatedaFunctionObject
std::packaged_tasktask(std::move(DBDataFetcher()));

//Fetchtheassociatedfuture<>frompackaged_task<>
std::futureresult=task.get_future();

//Passthepackaged_tasktothreadtorunasynchronously
std::threadth(std::move(task),"Arg");

//Jointhethread.Itsblockingandreturnswhenthreadisfinished.
th.join();

//Fetchtheresultofpackaged_task<>i.e.valuereturnedbygetDataFromDB()
std::stringdata=result.get();
std::cout<>>>>Apackaged_taskwon'tstartonit'sown,youhavetoinvokeit
std::packaged_tasktask(sleep);

autof=task.get_future();
task();//invokethefunction

//Youhavetowaituntiltaskreturns.Sincetaskcallssleep
//youwillhavetowaitatleast1second.
std::cout<<"Youcanseethisafter1second\n";

//However,f.get()willbeavailable,sincetaskhasalreadyfinished.
std::cout<>>>>Ontheotherhand,std::asyncwithlaunch::asyncwilltrytorunthetaskinadifferentthread:
autof=std::async(std::launch::async,sleep);
std::cout<<"Youcanseethisimmediately!\n";

//However,thevalueofthefuturewillbeavailableaftersleephasfinished
//sof.get()canblockupto1second.
std::cout<
GitHub：https://github.com/fengbingchun/Messy_Test
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

C++11中std::packaged_task的使用详解

热门推荐

随机推荐