std::future和std::packaged_task，std::promise，std::async

最近看到源码中有很多地方使用了future，packaged_task，上网搜搜，加上自己理解，使用一下，让自己看代码的时候能更加方便。

1.std::future和std::promise
std::future顾名思义是等待，希望的意思，std::promise顾名思义是承诺，则我们可以理解成，一个给与承诺，一个等待承诺。
通过建立一个承诺者std::promise，一个等待承诺者std::future，std::future是每一个承诺者std::promise中所带有的，通过std::future dataFuture = dataPromise.get_future();，建立一个std::future,然后通过调用dataFuture.get()进行等待，此时是阻塞的，直到线程thPromise调用了dataPromise.set_value(10)，将数据放进了承诺者中，则此时dataFuture.get()，得到数据，得到的值就是set_value中的数据。
参考代码如下：

#include 
#include 
int main()
{
    std::promise dataPromise;                                  //建立一个承诺
    std::future dataFuture = dataPromise.get_future();         //每个承诺的等待者
    std::thread thPromise([&dataPromise]
    {
        std::cout << "Enter thPromise" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(2));
        dataPromise.set_value(10);                                  //承诺兑现
    });
    std::thread thFuture([&dataFuture]
    {
        std::cout << dataFuture.get() << std::endl;                 //得到承诺成果
    });
    thPromise.join();
    thFuture.join();
    return 0;
}

2.std::future和std::packaged_task
std::promise后又有了一个更抽象的模拟，它支持函数调用返回值被std::future所等待。它就是std::packaged_task，顾名思义，任务包，将之前的承诺抽象成一个任务，执行完成后，返回给std::future函数执行的结果，它支持函数返回值被等待，不需要如std::promsie一样去调用set_value才被std::future接收。同样std::future使用get方法进行阻塞等待。
参考代码如下：

#include 
#include 

int main()
{
    std::packaged_task dataTask([]()                                   //建立任务
    {
        std::this_thread::sleep_for(std::chrono::seconds(2));
        return 20;
    });
    auto dataFuture = dataTask.get_future();                                  //任务的等待着，等待任务结束
    std::thread thTask([&dataTask]()
    {
        dataTask();                                                           //创建线程执行任务
    });
    std::thread thFuture([&dataFuture]()
    {
        std::cout << dataFuture.get() << std::endl;                           //得到任务结果
    });
    thTask.join();
    thFuture.join();
    return 0;
}

3.std::future和std::async
最后来看看std::async，这个比较有意思，以前我们使用异步执行某些任务时，都是new一个新的线程，执行完后再使用线程同步机制进行获取。现在直接使用std::async就可以解决，它已经封装好了，我们直接使用即可。说明一下std::async中的参数有async(launch _Policy, _Fty&& _Fnarg, _ArgTypes&&... _Args)，其中launch可以有两个选择：enum class launch {async = 0x1,deferred = 0x2};，deferred 是执行future.get()前执行函数，async 就是并行执行。
参考代码如下：

#include 
#include 
#include 
#include 

int main()
{
    //std::future dataFuture = std::async(std::launch::deferred, []()
    std::future dataFuture = std::async(std::launch::async, []()
    {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        return 1;
    });
    std::cout << "data : " << dataFuture.get() << std::endl;
    return 0;
}

4.在源码中看到的用法
将任务参数通过bind将参数绑定，构建一个shared_ptr管理任务，将任务投放到工作线程中去，执行完后，在主线程能够得到任务的结果（将bind与packaged_task结合到一起，在线程池中投放任务时，变得方便）。

#include 
#include 
#include 
#include 

int Test(int a, int b)
{
    return a + b;
}
int main()
{
    //Test绑定两个参数，在线程池中，任务投放被应用，参数绑定到线程中执行。future等待
    auto task = std::make_shared>(std::bind(&Test, 12, 23));   //bind任务
    auto fu = task->get_future();                                                        //得到future
    std::thread th([task]()
    {
        std::this_thread::sleep_for(std::chrono::seconds(2));
        (*task)();                                                                       //执行任务
    });
    std::cout << fu.get() << std::endl;                                                  //阻塞等待任务完成
    th.join();
    return 0;
}