当前位置：首页 > article >正文

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

article 2024/10/19 16:39:53

为了便于理解 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>>()) {}

    // 设置值并通知 future
    void 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 和 future
    auto [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;
}

代码流程解析

共享状态：SharedState 负责存储值，set_value 在设置值后通知等待的线程，get_value 阻塞直到值被设置。
SimplePromise：管理 SharedState 并设置值。
SimpleFuture：等待并获取值。
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    |
+----------------+      +-------------------+       +----------------+