C++11多线程编程 9.async、future、packaged_task、promise

#include<iostream>
#include<string>
#include<thread>
#include<asyncinfo.h>
#include<future>
#include<vector>
using namespace std;
class A
{
public:
    int mythread2(int mypar)
    {
        cout << mypar << endl;
        cout << "mythred() start" << "thred id =" << std::this_thread::get_id() << endl;//打印新线程的ID
        std::chrono::milliseconds dura(5000);//定义一个5秒的时间
        std::this_thread::sleep_for(dura);//休息了五秒
        cout << "mythred() start" << "thred id =" << std::this_thread::get_id() << endl;//打印新线程的ID
        return 5;
    }
};
int mythread()
{
    cout << "mythred() start" << "thred id =" << std::this_thread::get_id() << endl;//打印新线程的ID
    std::chrono::milliseconds dura(5000);//定义一个5秒的时间
    std::this_thread::sleep_for(dura);//休息了五秒
    cout << "mythred() start" << "thred id =" << std::this_thread::get_id() << endl;//打印新线程的ID
    return 5;
}

int mythread3(int mypar)
{
    cout << mypar << endl;
    cout << "mythred() start" << "thred id =" << std::this_thread::get_id() << endl;//打印新线程的ID
    std::chrono::milliseconds dura(5000);//定义一个5秒的时间
    std::this_thread::sleep_for(dura);//休息了五秒
    cout << "mythred() start" << "thred id =" << std::this_thread::get_id() << endl;//打印新线程的ID
    return 5;
}

//std::promise
void mythread5(std::promise<int> &tmpp ,int calc) {//操作的变量为整形，返回的是int，运算结果是整型，所以是int
    //做一系列复杂运算。
    calc++;
    calc *= 10;
    //做其他运算，花费了五秒。
    std::chrono::milliseconds dura(5000);//定义一个5秒的时间
    std::this_thread::sleep_for(dura);//休息了五秒
    int result = calc;//保存结果
    tmpp.set_value(result);//结果我保存到了tmpp这个对象中
    return;
}
//创建一个新线程，用上面线程的值
void mythread6(std::future<int> &tmpp)
{
    auto result = tmpp.get();
    cout << result << endl;
    return;

}
int main()
{
    /*    （1）std::async、std::future创建后台任务并返回
    *        希望线程返回一个结果
    *        std::async是一个函数模板，用来启动一个异步任务，启动后，返回一个std::future对象，这是一个类模板
    *            什么叫“启动一个异步任务”，就是自动创建一个线程，并开始执行对应的线程入口函数，他返回一个std::future对象
    *                这个对象里面就含有这个线程入口函数所返回的结果（线程返回的结果），我们可以通过调用这个future对象的成员函数get（）来获取结果。
    *            “future”将来的意思，有人也称呼std::future提供了一种访问异步操作结果的机制，就是说这个结果你可能没有办法马上拿到，但是不久的将来
    *                （线程执行完毕）的时候，你就能拿到结果了，所以大家就这么理解：这个future里会保存一个值。在将来的某个时刻能够拿到    
                我们通过额外向std::async()传递一个参数，该参数的类型是std::lunnch类型（枚举类型），来达到一些特殊的目的。
                    a)std::launch::deferred;表示线程入口函数调用被延迟到std::future的wait()或者get()函数调用时才执行。
                        问题：那如果wait（）或者get（）没有执行，这个线程会执行吗？    
                        答案：线程根本就没创建，所以也没执行。
                      std::launch::deferred;延迟调用，并且没有创建新线程，是在主线程中调用的线程入口函数；
                    b)std::launch::async，在调用async函数的时候就开始创建线程。
                        async()函数默认的用的是std::launch::async | std::launch::deferred 系统会根据自己需求选择二者其一。
            经过package_task或者std::promise打包后用get_future()获得future对象，后面还需要用get得到该对象保存的值。如果没有打包，原生的future类对象则直接用get获得值
    *    （2）std::package_task :打包任务，把任务包装起来
    *        是个类模板，它的模板参数是各种可调用对象（函数，类中圆括号重载，类对象），通过std::package_task将各种可调用对象包装起来，方便作为线程入口函数来调用。
    *        package_task包装起来的可调用对象还可以直接调用，所以从这个角度讲，package_task，也是一个可调用对象。
        （3）std::promise
            类模板，作用：我们在某个线程中给他赋值，在其他线程中把这个值取出来使用。
            通过promise保存一个值，在将来某个时刻我们通过吧一个future绑定到这个promise上来得到这个绑定的值
    *    （4）小结 :到底怎么用，什么时候用
    *        我们学这些东西的目的，并不是把他们都用在实际开发中，
    *        相反，如果咱们能够用最少的东西写出稳定高效的多线程程序，更值得赞赏；
    *        我们为了成长，必须要阅读一些高手的代码，从而加速实现自己代码的积累，我们的技术就会有大幅度的提升。
    *        
    */

    //下列程序通过std::future对象的get（）成员函数等待线程执行结束并返回结果。
    //这个get函数很牛，不拿到将来的返回值誓不罢休，不拿到值我就卡在这里等待拿值。
    A a;
    cout << "main" << " thread is " << std::this_thread::get_id() << endl;
    //std::future<int> result = std::async(mythread);//创建一个线程并开始执行。绑定关系，如果线程入口函数有参数，那么从第二个参数开始给参数的值
                                            //通过系统的async创建一个异步任务，也就是开启一个新线程，线程入口函数为mythread
    //std::future<int> resule = std::async(&A::mythread2,&a,12);//第一个参数为成员函数的地址，第二个为对象引用，才能保证线程里边用的是同一个对象。，从第三个开始给参数的地址。
    //std::future<int> result = std::async(std::launch::deferred, mythread);//系统延迟执行，如果不调用get不执行。
    std::future<int> result = std::async(std::launch::async, mythread);//系统默认标记，不需要等get或者wait就可以创建线程并且执行。

    cout << "continue.....!" << endl;
    int def;
    cout << result.get();//卡在这里等待mythread()执行完毕，拿到结果。
    // result.get();//不能调用多次，调用多次就报异常，只能调用一次
    result.wait();//只是等待，不接收返回值。类似于join

    //std::pacckage_task
    cout << "main" << "thread id =" << std::this_thread::get_id() <<  endl;
    std::packaged_task<int(int)> mypt(mythread);//我们把函数mythread通过package_task包装起来
    std::thread t1(std::ref(mypt),1);//ref纯引用，防止复制,1为线程入口函数的参数,线程直接开始执行。
    t1.join();//等待线程执行完毕
    std::future<int> result1 = mypt.get_future();//std::future对象里包含有线程入口函数的返回结果，这里result保存muthread返回的结果。
    cout << result1.get() << endl;

    //可以包装lambda表达式
    std::packaged_task<int(int)> mypt2([](int mypar) {//第一个int为返回类型为整形，第二个int为参数为整形，将这种函数包装到package_task里面去。
        cout << mypar << endl;
        cout << "mythred() start" << "thred id =" << std::this_thread::get_id() << endl;//打印新线程的ID
        std::chrono::milliseconds dura(5000);//定义一个5秒的时间
        std::this_thread::sleep_for(dura);//休息了五秒
        cout << "mythred() start" << "thred id =" << std::this_thread::get_id() << endl;//打印新线程的ID
        return 5;
        });
    //调用package_task ,没有创建线程，相当于函数调用。
    //mypt2(105);
    //std::future<int> result =mypt2.getfuture();
    //cout<<result.get()<<endl;

    vector<std::packaged_task<int(int)>> mypt4;
    mypt4.push_back(std::move(mypt2));//容器，这里mypt2为空了。

    std::packaged_task<int(int)> mypt5;
    auto itor = mypt4.begin();
    mypt5 = std::move(*itor);//换一个位置。
    mypt4.erase(itor);//删除第一个元素，迭代已经失效了，所以后续代码不可以再使用itor
    mypt5(102);
    std::future<int> result1 = mypt5.get_future();
    cout << result1.get();

    //std::promise
    std::promise<int> myprom;//声明一个std::promise对象myprom,保存的值类型为int；
    std::thread ti(mythread5, std::ref(myprom), 180);
    ti.join();
    //获取结果值
    std::future<int> ful = myprom.get_future();//promise和future绑定，用于获取线程返回值。
    auto resultt = ful.get();//会立即拿到。
    cout << "result=" << resultt << endl;

    //让另一个线程用上面这个代码的线程所返回的值
    std::thread myproo(mythread6, std::ref(ful));
    myproo.join();//等待myproo线程执行完毕 

}