九、async、future、packaged_task、promise

std::async、std::future创建后台任务并返回值。

希望线程返回一个值。

std::async是个函数模板，用来启动一个异步任务，返回一个std::future对象

异步任务：自动创建一个线程并开始执行对应的线程入口函数，返回一个std::future对象。

这个对象里面就含有线程函数所返回的结果（线程返回的结果），可以通过调用future对象的成员函数get()来获得。

future：也有人称呼future提供了一个访问异步操作结果的机制，意思是这个结果你可能没有办法立马得到，在不久的将来，在现场执行完毕后，你就能拿到这个结果的，可以理解为，future对象会保存一个值，在将来的某个时刻能够拿到。

 #include <future>
 #include <thread>

 using namespace std;

 int mythread(){
     cout<<std::this_thread::get_id()<<endl;
     std::chrono::milliseconds dura();//定义了5秒
     std::this_thread::sleep_for(dura);//休息了5秒
     return ;
 }
 int main(){
     cout << "main" << this_thread::get_id() <<endl;
     std::future<int> result = std::async(mythread);//创建了一个线程，同thread类似，第一个参数是线程函数，第二个参数是对象引用，第三个之后的是线程函数的参数
     cout<<"continue..."<<endl;
     int def;
     def=;
     cout<<result.get()<<endl;//系统执行到这里会卡到这儿等待子线程，等线程返回5后，继续向下走
                             //只能调用一次，在调用get就会出错
     //result.wait();等待线程返回本身不返回结果
     cout<<"main over"<<endl;
     return ;

 }

还可以在最前面添加一个参数，该参数类型是std::lunch类型（枚举类型），来达到一些特殊目的；
延迟调用，并且没有创建新线程，是在主线程中调用的线程入口函数
std::launch::deferred:表示线程入口函数调用被延迟到std::future的wait()或者get()函数调用才执行。
如果wait或get没有被调用，那么线程就根本就没执行也没创建。
std::future<int> result = std::async(std::lunch::deferred,mythread);

前面还有一个参数，是默认的std::launch::async，在调用async函数的时候就创建线程了。

std::packaged_task

打包任务，把任务包装起来。

是个类模板，模板参数是各种可调用对象，通过这个函数把这种可调用对象包转起来，方便将来作为线程入口函数来调用

 #include <future>
 #include <thread>

 using namespace std;

 int mythread(int& pt){
     cout << pt << endl;
     return ;
 }
 int main(){
     //写法一：
     std::packaged_task<int(int)> mypt(mythread);//把函数mythread通过packaged_task包装起来,int(int)：第一个int表示线程函数返回类型，括号里的int是线程函数的参数类型
     std::thread t1(std::ref(mypt),);//线程直接开始执行,第二个参数就是线程入口函数的参数
     t1.join();
     std::future<int> result = mypt.get_future();
     cout<<result.get()<<endl;
     return ;

     //写法二:用lambda表达式
     //这个时候，上面的mythread函数就删掉，相当于将线程入口函数定义写到了这个lambda表达式里面了。
     std::packaged_task<int(int)> mypt([](int pt){
         cout << pt << endl;
         return ;

     })
 }

作用是：

可以使用vector<std::packaged_task<int(int)> > mytask;//用一个容器来保存所有线程入口函数对象

怎么往容器里面添加对象？

std::packaged_task<int(int)> mypt(mythread);
mytasks.push_back(std::move(mypt));//move之后，mypt就空了

怎么取出来？

std::packaged_task<int(int)> mypt2;
auto iter = mytasks.begin();//假设此时这个vector里面只有一个对象
myptr2 = std::move(*iter);//移动语义
mytasks.erase(iter);
std::future<int> result = myptr2.get_future();
cout<<result.get()<<endl;

std::promise，类模板

在某个线程中给他赋值，然后可以在其他线程中把这个值取出来用。

 void mythread(std::promise<int>& tmp,int calc){
     //做一些列复杂操作
     int result = calc;//保存结果
     tmp.set_value(result);//结果保存到了tmp对象中
     return;
 }

 int main(){
     std::promise<int> myprom;//声明一个promise型对象，保存的值类型为int
     std::thread t1(mythread,std::ref(myprom),);
     t1.join();

     //获取结果值
     std::future<int> ful = myprom.get_future();
     auto result = ful.get();//get只能调用一次
     cout<<result<<endl;
 }