C++11之std::future和std::promise和std::std::packaged_task

為什么C++11引入std::future和std::promise？C++11創建了線程以后，我們不能直接從thread.join()得到結果，必須定義一個變量，在線程執行時，對這個變量賦值，然后執行join()，過程相對繁瑣。

　　thread庫提供了future用來訪問異步操作的結果。std::promise用來包裝一個值將數據和future綁定起來，為獲取線程函數中的某個值提供便利，取值是間接通過promise內部提供的future來獲取的，也就是說promise的層次比future高。 

#include "stdafx.h"
#include <iostream>
#include <type_traits>
#include <future>
#include <thread>

using namespace std;
int main()
{
    std::promise<int> promiseParam;
    std::thread t([](std::promise<int>& p)
    {
        std::this_thread::sleep_for(std::chrono::seconds(10));// 線程睡眠10s
        p.set_value_at_thread_exit(4);//
    }, std::ref(promiseParam));
    std::future<int> futureParam = promiseParam.get_future();

    auto r = futureParam.get();// 線程外阻塞等待
    std::cout << r << std::endl;

    return 0;
}

　　上述程序執行到futureParam.get()時，有兩個線程，新開的線程正在睡眠10s，而主線程正在等待新開線程的退出值，這個操作是阻塞的，也就是說std::future和std::promise某種程度也可以做為線程同步來使用。

　　std::packaged_task包裝一個可調用對象的包裝類（如function，lambda表達式（C++11之lambda表達式），將函數與future綁定起來。std::packaged_task與std::promise都有get_future()接口，但是std::packaged_task包裝的是一個異步操作，而std::promise包裝的是一個值。

#include "stdafx.h"
#include <iostream>
#include <type_traits>
#include <future>
#include <thread>

using namespace std;
int main()
{
    std::packaged_task<int()> task([]() {
        std::this_thread::sleep_for(std::chrono::seconds(10));// 線程睡眠10s
        return 4; });
    std::thread t1(std::ref(task));
    std::future<int> f1 = task.get_future();
    
    auto r = f1.get();// 線程外阻塞等待
    std::cout << r << std::endl;

    return 0;
}

std::future

　　std::future是一個非常有用也很有意思的東西，簡單說std::future提供了一種訪問異步操作結果的機制。從字面意思來理解，它表示未來，我覺得這個名字非常貼切，因為一個異步操作我們是不可能馬上就獲取操作結果的，只能在未來某個時候獲取，但是我們可以以同步等待的方式來獲取結果，可以通過查詢future的狀態（future_status）來獲取異步操作的結果。future_status有三種狀態：

• deferred：異步操作還沒開始
• ready：異步操作已經完成
• timeout：異步操作超時

//查詢future的狀態
std::future_status status;
    do {
        status = future.wait_for(std::chrono::seconds(1));
        if (status == std::future_status::deferred) {
            std::cout << "deferred\n";
        } else if (status == std::future_status::timeout) {
            std::cout << "timeout\n";
        } else if (status == std::future_status::ready) {
            std::cout << "ready!\n";
        }
    } while (status != std::future_status::ready); 

　　獲取future結果有三種方式：get、wait、wait_for，其中get等待異步操作結束並返回結果，wait只是等待異步操作完成，沒有返回值，wait_for是超時等待返回結果。

std::promise

　　std::promise為獲取線程函數中的某個值提供便利，在線程函數中給外面傳進來的promise賦值，當線程函數執行完成之后就可以通過promis獲取該值了，值得注意的是取值是間接的通過promise內部提供的future來獲取的。它的基本用法：

    std::promise<int> pr;
    std::thread t([](std::promise<int>& p){ p.set_value_at_thread_exit(9); },std::ref(pr));
    std::future<int> f = pr.get_future();
    auto r = f.get();

std::packaged_task

　　std::packaged_task它包裝了一個可調用的目標（如function, lambda expression, bind expression, or another function object）,以便異步調用，它和promise在某種程度上有點像，promise保存了一個共享狀態的值，而packaged_task保存的是一個函數。它的基本用法：

#include <chrono>
#include <functional>

int Test_Fun(int a, int b, int &c)
{
//a=1,b=2,c=0

//突出效果，休眠5s
std::this_thread::sleep_for(std::chrono::seconds(5));

//c=233
c = a + b + 230;

return c;
}

int main()
{
//聲明一個std::packaged_task對象pt1，包裝函數Test_Fun
std::packaged_task<int(int, int, int&)> pt1(Test_Fun);
//聲明一個std::future對象fu1，包裝Test_Fun的返回結果類型，並與pt1關聯
std::future<int> fu1 = pt1.get_future();

//聲明一個變量
int c = 0;

//創建一個線程t1，將pt1及對應的參數放到線程里面執行
std::thread t1(std::move(pt1), 1, 2, std::ref(c)); //這必須用轉移,或std::ref(pt1)
t1.join();
//阻塞至線程t1結束(函數Test_Fun返回結果)
int iResult = fu1.get();

std::cout << "執行結果：" << iResult << std::endl; //執行結果：233
std::cout << "c：" << c << std::endl; //c：233

system("pause");
return 1;
}

　　

而std::async比std::promise, std::packaged_task和std::thread更高一層，它可以直接用來創建異步的task，異步任務返回的結果也保存在future中。std::async的原型：

async( std::launch policy, Function&& f, Args&&... args );

　　std::launch policy有兩個，一個是調用即創建線程（std::launch::async），一個是延遲加載方式創建線程（std::launch::deferred），當掉使用async時不創建線程，知道調用了future的get或者wait時才創建線程。之后是線程函數和線程參數。

#include "stdafx.h"
#include <iostream>
#include <future>
#include <thread>

int main()
{
    // future from a packaged_task
    std::packaged_task<int()> task([]() { 
        std::cout << "packaged_task started" << std::endl;
        return 7; }); // wrap the function
    std::future<int> f1 = task.get_future();  // get a future
    std::thread(std::move(task)).detach(); // launch on a thread

                                           // future from an async()
    std::future<int> f2 = std::async(std::launch::deferred, []() { 
        std::cout << "Async task started" << std::endl;
        return 8; });

    // future from a promise
    std::promise<int> p;
    std::future<int> f3 = p.get_future();
    std::thread([&p] { p.set_value_at_thread_exit(9); }).detach();

    f1.wait();
    f2.wait();
    f3.wait();
    std::cout << "Done!\nResults are: "
        << f1.get() << ' ' << f2.get() << ' ' << f3.get() << '\n';
}