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

127 阅读 0 评论 84 点赞

我是靠谱客的博主明理钢笔，这篇文章主要介绍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<int> dataFuture = dataPromise.get_future();，建立一个std::future,然后通过调用dataFuture.get()进行等待，此时是阻塞的，直到线程thPromise调用了dataPromise.set_value(10)，将数据放进了承诺者中，则此时dataFuture.get()，得到数据，得到的值就是set_value中的数据。
参考代码如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <iostream>
#include <future>
int main()
{
std::promise<int> dataPromise;
//建立一个承诺
std::future<int> 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方法进行阻塞等待。
参考代码如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>
#include <future>
int main()
{
std::packaged_task<int()> 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 就是并行执行。
参考代码如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <thread>
#include <iostream>
#include <chrono>
#include <future>
int main()
{
//std::future<int> dataFuture = std::async(std::launch::deferred, []()
std::future<int> 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结合到一起，在线程池中投放任务时，变得方便）。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <thread>
#include <iostream>
#include <chrono>
#include <future>
int Test(int a, int b)
{
return a + b;
}
int main()
{
//Test绑定两个参数，在线程池中，任务投放被应用，参数绑定到线程中执行。future等待
auto task = std::make_shared<std::packaged_task<int()>>(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;
}