c++ std::future 和 std::promise 的实现工作原理简介

为了便于理解 std::future 和 std::promise 的实现工作原理，我们可以创建一个简化的版本。这包括共享状态、Promise 设置值、Future 获取值的核心机制。我们的示例代码将实现 SimplePromise 和 SimpleFuture 两个类，二者通过一个共享状态实现线程间的通信和同步。

实现代码

1. 定义共享状态

共享状态是 Promise 和 Future 之间共享的数据区域，用于存储值以及同步访问。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <optional>template <typename T>
class SharedState {
public:// 设置值void set_value(T value) {std::lock_guard<std::mutex> lock(mtx_);value_ = value;ready_ = true;cv_.notify_all();}// 获取值（阻塞直到值设置完成）T get_value() {std::unique_lock<std::mutex> lock(mtx_);cv_.wait(lock, [this] { return ready_; });return *value_;}private:std::mutex mtx_;std::condition_variable cv_;std::optional<T> value_;  // 使用optional来保存值（类似于指针，但更安全）bool ready_ = false;      // 表示是否设置了值
};

2. 实现 SimplePromise

SimplePromise 用于设置共享状态中的值。其主要功能包括创建共享状态实例，并在 set_value 中向状态中写入值。

template <typename T>
class SimplePromise {
public:SimplePromise() : state_(std::make_shared<SharedState<T>>()) {}// 设置值并通知 futurevoid set_value(T value) {state_->set_value(value);}// 获取 future 对象std::shared_ptr<SharedState<T>> get_state() {return state_;}private:std::shared_ptr<SharedState<T>> state_;
};

3. 实现 SimpleFuture

SimpleFuture 从共享状态中获取值，并在 get 中阻塞等待值设置完成。

template <typename T>
class SimpleFuture {
public:SimpleFuture(std::shared_ptr<SharedState<T>> state) : state_(state) {}// 获取值（会阻塞，直到值设置完成）T get() {return state_->get_value();}private:std::shared_ptr<SharedState<T>> state_;
};

4. 连接 SimplePromise 和 SimpleFuture

为了实现 std::promise 和 std::future 的连接，我们让 SimplePromise 创建共享状态实例，并通过该实例创建 SimpleFuture。

template <typename T>
std::pair<SimplePromise<T>, SimpleFuture<T>> make_promise_future() {SimplePromise<T> promise;SimpleFuture<T> future(promise.get_state());return {promise, future};
}

使用示例

下面的示例展示了如何使用 SimplePromise 和 SimpleFuture 进行线程间的值传递。

int main() {// 创建 promise 和 futureauto [promise, future] = make_promise_future<int>();// 启动线程异步设置值std::thread t([&promise]() {std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟延迟promise.set_value(42);std::cout << "值已设置为 42" << std::endl;});// 主线程等待并获取结果std::cout << "等待结果..." << std::endl;int result = future.get();std::cout << "获取到结果: " << result << std::endl;t.join(); // 等待线程结束return 0;
}

代码流程解析

1. 共享状态：SharedState 负责存储值，set_value 在设置值后通知等待的线程，get_value 阻塞直到值被设置。
2. SimplePromise：管理 SharedState 并设置值。
3. SimpleFuture：等待并获取值。
4. make_promise_future：帮助创建关联的 SimplePromise 和 SimpleFuture 对象。

工作流程图

+----------------+      +-------------------+       +----------------+
|   Thread 1     |      |   Shared State    |       |   Thread 2     |
+----------------+      +-------------------+       +----------------+
| SimplePromise  | ---> |  set_value(val)   | <---  | SimpleFuture   |
|                |      |   value = val     |       | get() blocking |
|   set_value(42)|      |  ready = true     |       | until ready    |
+----------------+      +-------------------+       +----------------+

总结

在这个实现中：

• SimplePromise 通过共享状态的指针持有对共享状态的唯一引用。
• SimpleFuture 在 get 方法中阻塞，直到 SimplePromise 在 set_value 中通知共享状态已经就绪。
• 共享状态通过条件变量和互斥锁确保线程安全，实现了异步值传递。