C++11提供了以下異步操作相關(guān)的類

• std::future : 作為異步結(jié)果的傳輸通道，可以很方便的獲取線程函數(shù)的返回值
• std::promise: 用來包裝一個(gè)值，將數(shù)據(jù)與future綁定起來
• std::package_task: 包裝一個(gè)調(diào)用對(duì)象，將函數(shù)和future綁定起來，方便異步調(diào)用

線程異步操作函數(shù)std::async

在介紹上面的類之前，先來介紹下線程異步操作函數(shù)。
這是一個(gè)比std::promise、std::packaged_task和std::thread更高層次的操作,使得我們不用關(guān)注線程創(chuàng)建的細(xì)節(jié)。其返回結(jié)果為future。
創(chuàng)建有兩種策略：

• std::launch::async: 在調(diào)用async時(shí)創(chuàng)建線程
• std::launch::deferred:延遲加載方式創(chuàng)建線程。調(diào)用時(shí)不創(chuàng)建線程，直到調(diào)用了future的get或者wait時(shí)才創(chuàng)建線程。

獲取線程函數(shù)返回值的類std::future

一個(gè)異步操作的結(jié)果不能馬上獲取，只能在未來的某個(gè)地方獲取，這個(gè)異步操作的結(jié)果是一個(gè)未來的期待值，因此稱為future。我們可以通過同步等待的方式來獲取結(jié)果，可以通過查詢future的狀態(tài)來獲取異步操作的結(jié)果。

future_status有以下三種狀態(tài)。

• deferred ： 異步操作還沒開始
• ready：異步操作已經(jīng)完成
• timeout： 異步操作超時(shí)

future有三種基本操作：

• get:獲取返回結(jié)果值
• wait: 只等待異步操作完成
• wait_for : 超時(shí)等待返回結(jié)果

#include<iostream>
#include<thread> 
#include<future>
#include<chrono>

int main() {

    std::future<int> future = std::async(std::launch::async, [](){ 
        std::this_thread::sleep_for(std::chrono::seconds(1));
        return 8;  
    }); 
    std::future_status status;
    do {
        status = future.wait_for(std::chrono::seconds(2));//等待2秒后返回結(jié)果 
        switch(status) {
            case std::future_status::deferred:
                std::cout << "deferred" << std::endl;
            break;
            case std::future_status::ready:
                std::cout << "ready" << std::endl;
            break;
            case std::future_status::timeout:
                std::cout << "timeout" << std::endl;
            break;
            default:
                break;
         }
     } while(status != std::future_status::ready);
     
    std::cout << "result is " << future.get() << '\n';
}

協(xié)助線程賦值的類std::promise

std::promise為外面?zhèn)鬟M(jìn)來的promise賦值，在函數(shù)執(zhí)行完成后通過promise的future獲取該值。

#include<iostream>
#include<thread> 
#include<future>
#include<chrono>

int main() {

    std::promise<int> pr;
    std::thread t([](std::promise<int>& p){
        p.set_value(1);

//      p.set_value_at_thread_exit(9);
    }, std::ref(pr));
    std::future<int> f = pr.get_future();
    auto r = f.get();
    std::cout << r << std::endl; 
    t.join();
}

可調(diào)用對(duì)象的包裝類std::package_task

與std::promise類似，只是std::promise包裝的是參數(shù)，而std::package_task包裝的是方法

#include<iostream>
#include<thread> 
#include<future>
#include<chrono>

int main() {

    std::packaged_task<int()> task([]{return 2;});
    std::thread t(std::ref(task));
    std::future<int> f = task.get_future();
    auto r = f.get();
    std::cout << r << std::endl; 
    t.join();
}

總結(jié)起來，std::promise、std::packaged_task和std::future的關(guān)系如下

• 當(dāng)需要異步操作中的某個(gè)值時(shí)，可以用std::promise
• 當(dāng)需要異步操作的返回值時(shí)，可以用std::packaged_task(當(dāng)然，這也可以用std::promise實(shí)現(xiàn)）
• std::future是std::promise和std::pakaged_task的數(shù)據(jù)通道

shared_futured

• future不可拷貝，只能移動(dòng)。但shared_future可以拷貝。當(dāng)需要將future放進(jìn)容器中時(shí)，用shared_future
  shared_future的基本用法

#include<iostream>
#include<thread> 
#include<future>
#include<utility>
#include<vector>

int f(int x) {
    return x + 1;
}
int main() {
    std::packaged_task<int(int)> task(f);
    std::future<int> fut = task.get_future();   
    std::thread(std::move(task),2).detach();

    //future不能復(fù)制，不能放到容器中
    std::vector<std::shared_future<int>> v;
    std::shared_future<int> f = std::async(std::launch::async, [](int a, int b){return a + b;}, 2, 3);
    v.push_back(f);
//  v.push_back(fut);//error
    std::cout << "The shared_future result is" << v[0].get() << std::endl; 
}