九、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;
}