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

还可以在最前面添加一个参数，该参数类型是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 0;
}
int main(){
    //写法一：
    std::packaged_task<int(int)> mypt(mythread);//把函数mythread通过packaged_task包装起来,int(int)：第一个int表示线程函数返回类型，括号里的int是线程函数的参数类型
    std::thread t1(std::ref(mypt),1);//线程直接开始执行,第二个参数就是线程入口函数的参数
    t1.join();
    std::future<int> result = mypt.get_future();
    cout<<result.get()<<endl;
    return 0;
    
    //写法二:用lambda表达式
    //这个时候，上面的mythread函数就删掉，相当于将线程入口函数定义写到了这个lambda表达式里面了。
    std::packaged_task<int(int)> mypt([](int pt){
        cout << pt << endl;
        return 0;
    
    })
}

作用是：

可以使用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),180);
    t1.join();
    
    //获取结果值
    std::future<int> ful = myprom.get_future();
    auto result = ful.get();//get只能调用一次
    cout<<result<<endl;
}