為什麼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::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';
}