九、std::async异步线程

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

std::async是一个函数模板，用来启动一个异步任务，启动起来一个异步任务之后，它返回一个std::future对象，这个对象是个类模板。

 

异步任务：就是自动创建一个线程，并开始 执行对应的线程入口函数，它返回一个std::future对象，这个std::future对象中就含有线程入口函数所返回的结果，我们可以通过调用future对象的成员函数get()来获取结果。

 

“future”将来的意思，也有人称呼std::future提供了一种访问异步操作结果的机制，就是说这个结果你可能没办法马上拿到，但是在不久的将来，这个线程执行完毕的时候，你就能够拿到结果了，所以，大家这么理解：future中保存着一个值，这个值是在将来的某个时刻能够拿到。

 

std::future对象的get()成员函数会等待线程执行结束并返回结果，拿不到结果它就会一直等待，有点像join()，但它可以获取结果。

#include <thread>
#include <iostream>
#include <list>
#include <map>
#include <mutex>
#include <future>
using namespace std;
class A {
public:
    int mythread(int mypar) {
        cout << mypar << endl;
        return mypar;
    }
};
 
 
int mythread() {
    cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl;
    std::chrono::milliseconds dura(5000);
    std::this_thread::sleep_for(dura);
    cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl;
    return 5;
}
 
 
int main() {
    A a;
    int tmp = 12;
    cout << "main" << "threadid = " << std::this_thread::get_id() << endl;
    std::future<int> result1 = std::async(mythread);
    cout << "主子并行........" << endl;
    cout << result1.get() << endl; //卡在这里等待mythread()执行完毕，拿到结果，只能调用一次
    
    //类成员函数
    std::future<int> result2 = std::async(&A::mythread, &a, tmp); //参数是对象引用才能保证线程里执行的是同一个对象
    cout << result2.get() << endl;
    cout << "good luck" << endl;
    return 0;
}

通过向std::async()传递一个参数，改参数是std::launch类型（枚举类型），来达到一些特殊的目的：

1、std::lunch::deferred：

　　表示线程入口函数调用被延迟到，std::future的wait()或者get()函数调用时才执行；

　　如果wait()或者get()没有被调用，则不会执行。实际上根本就没有创建。（并不是并行执行，而是在主线程中调用的线程入口函数）。

2、std::launch::async

　　在调用async函数的时候就开始创建线程。async()这个函数默认用的就是std::launch::async标记。

std::packaged_task：打包任务，把任务包装起来。

类模板，它的模板参数是各种课调用对象，通过packaged_task把各种可调用对象包装起来，方便将来作为线程入口函数。（算了，不是很懂！）

#include <thread>
#include <iostream>
#include <list>
#include <map>
#include <mutex>
#include <future>
using namespace std;
 
int mythread(int mypar) {
    cout << mypar << endl;
    cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl;
    std::chrono::milliseconds dura(5000);
    std::this_thread::sleep_for(dura);
    cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl;
    return 5;
}
 
 
int main() {
    int tmp = 12;
    cout << "main" << "threadid = " << std::this_thread::get_id() << endl;
    std::packaged_task<int(int)> mypt(mythread); //我们把函数mythread通过packaged_task包装起来
    std::thread t1(std::ref(mypt), 1);
    t1.join();
    std::future<int> result = mypt.get_future(); 
    //std::future对象里包含有线程入口函数的返回结果，这里result保存mythread返回的结果。
    cout << result.get() << endl;
    cout << "good luck" << endl;
    return 0;
}

std::promise，类模板

我们能够在某个线程中给它赋值，然后我们可以在其他线程中，把这个值取出来。

#include <thread>
#include <iostream>
#include <list>
#include <map>
#include <mutex>
#include <future>
using namespace std;
 
void mythread(std::promise<int> &tmp, int clac) {
    cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl;
    std::chrono::milliseconds dura(5000);   
    std::this_thread::sleep_for(dura);
    cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl;
    int result = clac;
    tmp.set_value(result); //结果保存到了tmp这个对象中
    return;
}
 
vector<std::packaged_task<int(int)>> task_vec;
 
int main() {
    std::promise<int> myprom;
    std::thread t1(mythread, std::ref(myprom), 180);
    t1.join(); //在这里线程已经执行完了
    std::future<int> fu1 = myprom.get_future(); //promise和future绑定，用于获取线程返回值
    auto result = fu1.get();
    cout << "result = " << result << endl;
}

总结：通过promise保存一个值，在将来某个时刻我们通过吧一个future绑定到这个promise上，来得到绑定的值

std::future 的成员函数

wait_for()：主线程等你x秒，希望你返回值。

　　std::future_status::timeout：返回超时

　　\ std::future_status::ready：准时返回

　　\ std::future_status::deferred：线程延迟执行（实际并没有创建子线程，而是在主线程中执行）

#include <thread>
#include <iostream>
#include <list>
#include <map>
#include <mutex>
#include <future>
using namespace std;
 
int mythread() {
    cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl;
    std::chrono::milliseconds dura(5000);
    std::this_thread::sleep_for(dura);
    cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl;
    return 5;
}
 
 
int main() {
    A a;
    int tmp = 12;
    cout << "main" << "threadid = " << std::this_thread::get_id() << endl;
    std::future<int> result = std::async(mythread);
    cout << "continue........" << endl;
    //cout << result1.get() << endl; //卡在这里等待mythread()执行完毕，拿到结果
    std::future_status status = result.wait_for(std::chrono::seconds(1));
    if (status == std::future_status::timeout) {
        //超时：表示线程还没有执行完
        cout << "超时了，线程还没有执行完" << endl;
    }
    //类成员函数
    return 0;
}

std::shared_future：也是个类模板

std::future的 get() 成员函数是转移数据（移动语义），只能调用一次

　　auto res=tmp.get()；将相当于tmp中的返回值移动到res中了，tmp的返回值为空了。

std::shared_future 的 get() 函数是赋值数据

　　如果我多个线程都想要get()的返回值怎么办呢？就是这个了

#include <thread>
#include <iostream>
#include <list>
#include <map>
#include <mutex>
#include <future>
using namespace std;
 
int mythread() {
    cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl;
    std::chrono::milliseconds dura(5000);
    std::this_thread::sleep_for(dura);
    cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl;
    return 5;
}
 
int mythread2(std::shared_future<int> &res) {
    cout << "mythread2() start" << "threadid = " << std::this_thread::get_id() << endl;
    auto myresult3 = res.get();
    cout << "mythread2() end" << "threadid = " << std::this_thread::get_id() << endl;
    return 5;
}
 
int main() {
    int tmp = 12;
    cout << "main" << "threadid = " << std::this_thread::get_id() << endl;
    std::packaged_task<int()> mypt(mythread);
    std::thread t1(std::ref(mypt));
    std::future<int> result = mypt.get_future();
    //std::shared_future<int> result_s(std::move(result));
    bool ifcanget = result.valid(); //判断future 中的值是不是一个有效值
    std::shared_future<int> result_s(result.share()); //执行完毕后result_s里有值，而result里空了
    t1.join();
    
    auto myresult1 = result_s.get();
    auto myresult2 = result_s.get();
 
    std::thread t2(std::ref(mythread2), std::ref(result_s));
    t2.join();
    cout << "good luck" << endl;
    return 0;
}