我承诺会给你一个美好的未来

发表于 | 分类于

在以往的 C++98 中，多线程并行开发并不是那么容易的：你得小心翼翼地处理好「线程、锁、条件变量」的三角关系才能弄出个像样的多线程程序出来。

C++11 提供了 future 和 promise 来简化不同线程间的异步操作：

当一个任务需要向父线程（启动它的线程）返回值时，它把这个值放到 promise 中，之后，这个返回值会出现在和此 promise 关联的 future 中，于是父线程就能读到返回值。

在这种机制里，你只需要一个执行任务的线程，而不必再显示地使用其它的什么锁、条件变量等语义。

future

从字面意思看，它表示「未来」，通常我们不能立即获取到异步操作的执行结果，只能在未来某个时候获取。

一个有效的 future 对象通常由以下三种 provider 创建，并和某个共享状态相关联。

  • async 函数
  • promise::get_future
  • packaged_task::get_future

我们可以通过查询 future 的状态（future_status）来获取异步操作的结果。

future_status 有三种状态：

  • deferred：异步操作还没开始
  • ready：异步操作已经完成
  • timeout：异步操作超时

获取 future 结果有三种方式：

  • get 等待异步操作结束并返回结果
  • wait 只是等待异步操作完成，没有返回值
  • wait_for 超时等待返回结果

promise

promise 是个范型对象，可保存 T 类型的值，该值可被 future 对象在将来某个时刻读取。在构造 promise 时，promise 对象可以与共享状态关联起来，这个共享状态可以存储一个 T 类型或者一个由 std::exception 派生出的类的值，并可以通过 get_future 来获取与 promise 对象关联的对象，调用该函数之后，两个对象共享相同的共享状态(shared state)。

  • promise 对象是异步 provider，它可以在某一时刻设置共享状态的值。
  • future 对象可以返回共享状态的值，或者在必要的情况下阻塞调用者并等待共享状态标识变为 ready，然后才能获取共享状态的值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>  
#include <functional> 
#include <thread>  
#include <future> 

void print_int(std::future<int>& fut) {
    int x = fut.get(); 
    std::cout << "value: " << x << '\n'; 
}

int main ()
{
    std::promise<int> prom; 
    std::future<int> fut = prom.get_future(); 
    std::thread t(print_int, std::ref(fut)); 
    prom.set_value(10); 
    t.join();
    return 0;
}

packaged_task

packaged_task 和 promise 在某种程度上有点像，只不过 promise 保存了一个共享状态的值，而 packaged_task 保存的是一个可调用对象。

它包含了两个最基本元素：

  • 被包装的任务(stored task)，一个可调用的对象，如函数指针、成员函数指针或者函数对象。
  • 共享状态(shared state)，用于保存任务的返回值，可以通过 future 对象来达到异步访问共享状态的效果。
1
2
3
4
std::packaged_task<int()> task([](){ return 7; });
std::thread t1(std::ref(task)); 
std::future<int> f1 = task.get_future(); 
auto r1 = f1.get();

promise & future & packaged_task

promise 和 packged_task 都是异步 provider，都可以在将来某个时候设置与其关联的共享状态的值，它们内部都关联了一个 future 来异步访问共享状态的值。

稍微有点不同的是 packaged_task 包装的是一个异步操作、具体任务的返回值；而 promise 包装的是一个明确的、具体的值。

我的体会是：

需要直接读取线程函数中的某个值，就用 promise，需要获取异步操作的返回值，就用 packaged_task。

就这点细微的区别，我想用人类的语言解释一下。

比如，一个小伙子给一个姑娘表白真心的时候可能会说：「我承诺会给你一个美好的未来」或者「我会努力奋斗为你创造一个美好的未来」。

姑娘往往会说：「我等着」。

这三句话翻译成 C++11 语言就是：

小伙子说：「我承诺会给你一个美好的未来」等于 C++11 中 promise a future;

小伙子说：「我会努力奋斗为你创造一个美好的未来」等于 C++11 中 packaged_task a future;

姑娘梨花带雨地说：「我等着」等于 C++11 中 future.get()/wait();

小伙子两句话中的差异，自己琢磨一下，就是 promise 和 packaged_task 的差异，只可意会，不可言传吧。

现实中的山盟海誓靠不靠得住我不知道，但是 C++11 中的承诺和未来是一定可靠的，发起来了承诺就一定有未来，不管这个承诺是成功履行了（ready）或者出现了其它变故（exception）。

异步首选：async

C++11 还提供了异步接口 async，它会自动创建一个线程去执行线程函数，返回一个 future，这个 future 中存储了线程函数的返回值。

async 使我们可以在不显示调用线程的情况下就实现异步操作，获取异步执行状态和结果，真是 so easy，另外，它还提供了两种线程的创建策略。

1
async(std::launch::async | std::launch::deferred, f, args...)
  • std::launch::async：调用就开始创建线程，默认策略。
  • std::launch::deferred：延迟加载方式，调用时不创建线程，直到调用了 future 的 get 或者 wait 时才创建线程。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream> 
#include <future>  

// a non-optimized way of checking for prime numbers
bool is_prime (int x) 
{
  std::cout << "Calculating. Please, wait...\n";
  for (int i=2; i<x; ++i) if (x%i==0) return false;
  return true;
}

int main ()
{
  std::future<bool> fut = std::async (std::launch::deferred, is_prime, 313222313);
  std::cout << "Checking whether 313222313 is prime.\n";
  bool ret = fut.get();      // waits for is_prime to return

  if (ret) std::cout << "It is prime!\n";
  else std::cout << "It is not prime.\n";

  return 0;
}

总结

C++11 本身提供了统一的跨平台的线程语法，在此基础上，future 和 promise、packged_task、async 进一步地简化了线程的异步操作，使得程序员从以前的多线程噩梦中解脱出来，而将更多的注意力放在具体的业务逻辑上，这是生产力的巨大进步。

彦祖老师 wechat