女主宣言

由于工作需求，笔者最近在阅读 Pulsar C++ 客户端的实现，发现该客户端虽然是基于 C++11 编写的，但却自己编写了 Future 和 Promise 类，随着阅读的深入，也体会到了在这里”重复造轮子“的原因。本文将根据lib/Future.h中的源码，讲述C++中Future和Promise的一种简单实现~

PS：丰富的一线技术、多元化的表现形式，尽在“360云计算”，点关注哦！

1

前言

众所周知，C++11 提供了对并发编程的支持。首先提供了对不同平台的线程设施的简单包装 thread，并提供了 native_handle() 方法可以得到平台相关的线程句柄，从而调用底层线程相关的函数。另外，C++11 还提供了 future 和 promise 来支持基于任务的程序设计。

1

C++11的并发API

首先回顾下 C++11 的并发设施。

std::thread

如果熟悉 pthread 库的话，那么 C++11 的 std::thread 会非常容易上手，它使用了可变模板参数这一技术，使得编写线程函数不必麻烦地进行 void* 和 T* 的相互转换。

举个例子，要在线程中将两个 int 求和然后转换成十六进制字符串，得到结果。

使用 pthread 的代码：

#include #include #include using namespace std;struct Package {  int x, y;            // input  std::string result;  // output  void calculate() { result = std::to_string(x + y); }};int main(int argc, char* argv[]) {  pthread_t tid;  Package package{1, 3, ""};  pthread_create(      &tid, nullptr,      [](void* param) -> void* {  // 线程函数必须是 void* (void*)        static_cast(param)->calculate();        return nullptr;      },      &package);  // 传入 void* 作为输入参数  pthread_join(tid, nullptr);  // 第二个参数是 void**，如果非空的话可以得到线程函数返回的 void*  cout << "result: " << package.result << endl;  return 0;}

为了简化代码，这里忽略 pthread API 的返回值检查，以及 param 是否为空的检查。可见，pthread 需要对参数打包成一个结构体。

再看看 std::thread 的等价实现：

#include #include using namespace std;int main(int argc, char* argv[]) {  string result;  thread t([](int x, int y,              string& s) { s = to_string(x + y); },  // 函数签名是 T (Args...)           1, 3, ref(result));  t.join();  cout << "result: " << result << endl;  return 0;}

最大的改进是线程函数签名从底层的 void*(void*) 变成了返回任意类型、接收任意数量和类型的参数的 T(Args&&...)。注意传入引用时需要用 std::ref 将引用转换成可拷贝的某种结构。

如何得到返回值

问题来了，其实上面的实现并不直观，毕竟将计算结果作为返回值，比将计算结果的引用作为输入参数要更符合直观。

std::thread 直接就无法得到返回值。反而 pthread 线程函数可以返回的那个 void* 保存返回结果，比如：

#include #include #include using namespace std;struct Input {  int x, y;  std::string sum() const { return to_string(x + y); }};int main(int argc, char* argv[]) {  Input input{1, 3};  pthread_t tid;  pthread_create(      &tid, nullptr,      [](void* param) -> void* {        return new std::string(static_cast(param)->sum());      },      &input);  void* result;  pthread_join(tid, &result);  cout << "result: " << *static_cast<string*>(result) << endl;  // 注意：在某些编译器上 delete result 虽然也行得通，但 delete void* 的行为是未定义的行为(UB)  delete static_cast<string*>(result);  return 0;}

多了一次 new 以及一次拷贝构造的开销不谈，从代码上看，void* 和 T*的互相转换简直是噩梦一样，一不小心还容易内存泄漏。

std::future

std::future 很大程度上是用来解决 std::thread 无法得到返回值的问题的，比如基于 std::future 的等价代码为：

#include #include #include using namespace std;int main(int argc, char* argv[]) {  auto future_ = async([](int x, int y) { return to_string(x + y); }, 1, 3);  cout << "result: " << future_.get() << endl;  return 0;}

async 创建异步任务，get() 等待异步任务完成，并返回结果。

更多的细节就不讲了，比如其实的线程函数(姑且这么叫)是在主线程运行的(其实在主函数和线程函数中分别打印下 std::this_thread::get_id() 就能看出来)，除非显式指定启动策略(std::launch)为 std::launch::async。

总之，std::future 是基于 std::thread 的进一步抽象，对于使用者而言，用起来更加方便。并且还提供了一些超时控制的方法，避免如果结果没计算出来的话 get() 会一直阻塞。

std::promise

std::future 的缺点就是和 std::thread 绑定了，无法使用线程池或者得到底层线程库的句柄设置线程属性。另一方面，有时候调用者得到某个结果后，线程函数还想继续执行一些事情。这时候就可以用到 std::promise 了。

#include #include #include #include #include using namespace std;int main(int argc, char* argv[]) {  string input;  cout << "input: ";  cin >> input;  promise<int> p;  std::thread t(      [&p](const string& s) {        try {          int number = stoi(s);          p.set_value(number);  // 在此之后，p.get_future().get() 就能够返回了          // 线程继续做其他事情          this_thread::sleep_for(chrono::seconds(1));          cout << "thread do something else..." << endl;        } catch (...) {          // 处理出错，此处的异常会由 p.get_future().get() 重新抛出          p.set_exception(current_exception());      },      input);  try {    cout << "result: " << p.get_future().get() << endl;  } catch (const std::exception& e) {    cout << "Failed to parse: " << input << " to integer: " << e.what() << endl;  }  t.join();  return 0;}

运行示例：

$ ./a.out input: 12result: 12thread do something else...$ ./a.out input: xxFailed to parse: xx to integer: stoi

可见 std::promise 与一个 std::future 相关联，用户可以在任何地方去为 std::promise 设置返回结果或者异常。一旦设置完成，绑定的 std::future 处于完成状态，即之后若调用 get() 要么返回某个结果，要么抛出异常。

至于 std::promise 在何处设置返回结果或者异常，可以非常灵活，可以主线程直接设置，也可以在 std::thread 的线程函数中设置，也可以在线程池一类设施里设置。

2

Pulsar C++ 客户端的Future和Promise

Future

不同于 std::future 仅提供单个模板参数 T 用来表示线程函数的返回值，Future 需要两个模板参数 Result 和 Type，内部唯一字段 state_ 也是通过这两个参数来实例化：

template <typename Result, typename Type>class Future {   public:    // ...   private:    std::shared_ptr > state_;    // ...};

template <typename Result, typename Type>struct InternalState {    std::mutex mutex;    std::condition_variable condition;    Result result;    Type value;    bool complete;        std::list<typename std::function<void(Result, const Type&)> > listeners;};

重点是 listeners。它是若干函数组成的列表，函数接收 Result 和 const Type& 作为参数，这里大致猜测为回调？比如执行异步任务，返回结果 result 后，和 Type 类型的 value 传入回调进行处理？

注意到这里 Result 是传值，Type 是传常引用，大概 Result 是类似错误码一样的不超过 8 字节(指针大小)的整型，而 Type 则可能是一个比较大的结构体？带着猜测继续阅读 Future 暴露的方法：

首先是 addListener：

    Future& addListener(ListenerCallback callback) {        // 获取 shared_ptr 内部指针，用锁来保护指针指向对象的访问        InternalState* state = state_.get();        // Lock 即 std::unique_lock<:mutex>，可以手动 unlock 解锁，也可以等析构时自动解锁        Lock lock(state->mutex);        // complete 置为 true 则代表任务完成，此时提前解锁并执行回调(因为不会再修改 state 指向对象的值)        if (state->complete) {            lock.unlock();            callback(state->result, state->value);        } else {            // 而任务未完成时则将其加入 listeners 中，前面的锁就是为了保证 listeners 添加回调函数的线程安全            state->listeners.push_back(callback);        }        return *this;    }

其实只是添加一个回调。返回自身的引用是为了支持链式调用。

有一点值得斟酌，这里使用了 shared_ptr 内部的裸指针，而不是直接访问 shared_ptr 本身。这会出现一种可能：如果在其他线程中， state_ 被指向了其他对象，那么原来的对象引用计数就变成 0，从而析构，此时裸指针 state 指向的就是无效对象。

但是这里的 state_ 是私有字段，而且除了构造函数外也没有其它地方会修改它指向的对象，所以这个问题是不会发生的。

然后是 get() 方法，和 std::future 一样，也就是阻塞直到任务完成。

    Result get(Type& result) {        InternalState* state = state_.get();        Lock lock(state->mutex);        if (!state->complete) {            // Wait for result            while (!state->complete) {                state->condition.wait(lock);            }        }        result = state->value;        return state->result;    }

整个 Pulsar C++ 客户端的代码风格是使用错误码而非异常来报告错误的，所以可以看到，这里返回值是 Result，而任务结果是 Type 类型，通过引用型入参来得到的。

用 condition 字段来等待结果被设置。这里用了条件变量的一个惯用法，就是 while 循环来等待唤醒。刚接触条件变量的人可能会疑惑为什么不直接一个 if 完事呢，像这样：

 if (!state->complete) {      // 阻塞直到 condition 被 notify 唤醒，只要唤醒者在 notify 之前将 complete 置为 true 即可      state->condition.wait(lock);  }

在 The Linux Progamming Interface(《Linux/Unix 系统编程手册》)第 30.2.3 节有讲到，条件变量被 wait 返回时，不能确定判断条件的状态，原因是：

• 其他线程可能率先醒来，比如多个线程在等待同一条件变量，然后其他线程先被唤醒，而它们可能会重新改变条件的状态。

• 设置宽松的判断条件或许更为简单。

• 可能发生虚假唤醒的情况，也就是即使没有被 notify，也可能会被唤醒，在一些多处理器系统上，为确保高效实现可能会采用这种(不常见的)虚假唤醒实现。

总之，用 while 循环并不比 if 直接判断坏多少，最坏也就多一次 if 判断(这开销基本可以忽略)，但是能覆盖一些 corner case。

Promise

在 Future::get 方法中，state_.condition 会等待唤醒。而 state_ 是私有的并且没有暴露出来(当然，构造 Future 时可以暂存一份 shared_ptr 手动唤醒)。那么谁来唤醒呢？注意到 Future 的构造函数是私有的，并且声明了友元类：

    template <typename U, typename V>    friend class Promise;

template <typename Result, typename Type>class Promise {   public:    Promise() : state_(std::make_shared >()) {}    // ...    Future getFuture() const { return Future(state_); }   private:    typedef std::function<void(Result, const Type&)> ListenerCallback;    std::shared_ptr > state_;}

从构造函数可见，Promise 可以和 Future 共享 InternalState。并且 ListenerCallback 类型就是列表 InternalState.listeners 持有的函数类型。getFuture 方法会创建 Future 对象，由于使用 shared_ptr，这些 Future 和当前 Promise 共享一个 InternalState。

因为 Future 的构造函数是私有的，所以只能由 Promise::getFuture 来构造。

Promise 提供 3 个公有方法：

• bool isComplete() const：利用 mutex 字段上锁，返回 complete 字段的值，检查任务是否完成。

• setValue(const Type& value)：设置返回结果

• setFailed(Result result)：设置错误码

    bool setValue(const Type& value) {        InternalState* state = state_.get();        Lock lock(state->mutex);        // 若任务已完成，则设置失败，因此多线程设置任务返回值时，只有第一个能成功        if (state->complete) {            return false;        }        state->value = value;  // 设置任务返回值        state->result = Result();  // 设置错误码为默认值        state->complete = true;  // 标志任务已完成        // 遍历所有注册过的回调函数并依次调用        typename std::list::iterator it;        for (it = state->listeners.begin(); it != state->listeners.end(); ++it) {            ListenerCallback& callback = *it;            callback(state->result, state->value);        }        // 清空回调函数列表，唤醒所有阻塞在 get() 中的 Future        state->listeners.clear();        state->condition.notify_all();        return true;    }

setFailed 方法和 setValue 类似，唯一的不同就是对 InternalState 的 value 和 result 字段的设置：

 state->result = result;  // 仅仅设置错误码，不设置任务返回值

代码的一点瑕疵是，这里居然不用 range for 语法：

for (const auto& callback : state) {    callback(state->result, state->value);}

而是直接迭代器遍历 list，还写出了迭代器的长长类型而不用 auto。

PS：其实发现有不少地方都是这种 C++98 风格的，显式写出迭代器类型，然后用迭代器遍历容器。

3

重复造轮子?

至此整个实现就看完了，可以发现它只是实现了 C++11 的 std::future / std::promise 的一部分功能，它的使用套路是类似的，只不过它是基于错误码而非异常的(整个 Pulsar 客户端的错误处理风格也是基于错误码的)。

相比标准库而言，最大的特点就是支持注册回调函数，Promise 一旦设置了返回值或错误码，其绑定的 Future 中所有回调函数都会依次调用。这样就很方便实现一个支持异步和同步调用的类，比如将前文中使用 std::promise 的例子包装成 IntegerParser 类，然后提供同步和异步的接口：

enum class ErrorCode { kSuccess = 0, kInvalidFormat, kUserCallbackException };inline std::string strErrorCode(ErrorCode error) {  switch (error) {    case ErrorCode::kSuccess:      return "success";    case ErrorCode::kInvalidFormat:      return "invalid format";    case ErrorCode::kUserCallbackException:      return "exception from user's callback";  }  return "unknown error";  // 永远不会到达这里，仅仅是为了关闭编译警告}class IntegerParser { public:  // 异步 API，用户提供回调，注意，回调的参数2是 int 而非 const int&  Futureint> parseAsync(      const std::string& input, std::function<void(ErrorCode, int)> callback) {    std::thread t([&input, this] {      try {        int number = std::stoi(input);        promise_.setValue(number);      } catch (...) {        promise_.setFailed(ErrorCode::kInvalidFormat);      }    });    t.detach();    // 间接调用回调，并处理用户提供的回调可能抛出的异常    return promise_.getFuture().addListener(        [&callback](ErrorCode code, const int& result) {          try {            callback(code, result);          } catch (const std::exception& e) {            std::cerr << "[ERROR] User's callback throws: " << e.what()                      << std::endl;          }        });  }  // 同步 API，返回错误码，传入引用保存处理结果  ErrorCode parse(const std::string& input, int& result) {    auto parse_error = ErrorCode::kSuccess;    auto fut = parseAsync(input, [&parse_error](ErrorCode error, const int&) {      parse_error = error;    });    fut.get(result);    return parse_error;  } private:  Promiseint> promise_;};

360云计算

由360云平台团队打造的技术分享公众号，内容涉及数据库、大数据、微服务、容器、AIOps、IoT等众多技术领域，通过夯实的技术积累和丰富的一线实战经验，为你带来最有料的技术分享