基于 C++11 手写前端 Promise 实现

手写 CPromise 实现

类结构设计

核心在于状态管理和回调队列。我们需要定义三种状态：等待中（PENDING）、已完成（FULFILLED）和已拒绝（REJECTED）。

template<typename Element>
class CPromise {
private:
    using Resolve = std::function<void(Element)>;
    using Reject = std::function<void(const std::string&)>;

private:
    Element m_element;          // 异步操作的结果
    std::string m_reason;       // 拒绝的原因
    CPromiseState m_state;      // 当前状态
    std::list<Resolve> m_resolves; // 成功回调函数列表
    std::list<Reject> m_rejects;   // 失败回调函数列表

public:
    CPromise();
    void reject(const std::string& reason);
    void resolve(Element element);
    void onCatch(const Reject& rej);
    CPromise* then(const Resolve& res);
};

• Resolve 和 Reject：定义了成功和失败回调函数的类型。
• m_element 和 m_reason：分别存储 Promise 的结果和拒绝原因。
• m_state：表示 Promise 的当前状态，初始状态为 PENDING。
• m_resolves 和 m_rejects：存储注册的成功和失败回调函数列表。

构造函数与状态初始化

构造函数负责初始化状态为 PENDING，确保对象创建时处于可接受回调的状态。

CPromise::CPromise() : m_state(CPromiseState::PENDING) {}

状态变更与回调执行

当调用 resolve 或 reject 时，如果当前状态是 PENDING，则更新状态并立即执行所有注册的回调。这里要注意，一旦状态改变，后续不能再修改。

void CPromise::resolve(Element element) {
    m_element = element;
    if (m_state == CPromiseState::PENDING) {
        m_state = CPromiseState::FULFILLED;
        for (Resolve res : m_resolves) {
            res(element);
        }
    }
}

void CPromise::reject(const std::string& reason) {
    m_reason = reason;
    if (m_state == CPromiseState::PENDING) {
        m_state = CPromiseState::REJECTED;
        for (Reject rej : m_rejects) {
            rej(reason);
        }
    }
}

链式调用设计

为了让 API 像前端 Promise 一样流畅，then 方法返回 this 指针，允许连续调用。

CPromise* CPromise::then(const Resolve& res) {
    if (m_state == CPromiseState::FULFILLED) {
        res(m_element);
    } else if (m_state == CPromiseState::PENDING) {
        m_resolves.push_back(res);
    }
    return this;
}

void CPromise::onCatch(const Reject& rej) {
    if (m_state == CPromiseState::REJECTED) {
        rej(m_reason);
    } else if (m_state == CPromiseState::PENDING) {
        m_rejects.push_back(rej);
    }
}

实际使用中，我们可以这样组合：

CPromise<int>* promise = new CPromise<int>();
promise->then([](int ele) -> void {
    std::cout << ele << std::endl;
})->onCatch([](const std::string& reason) -> void {
    std::cout << reason << std::endl;
});
promise->reject("网络异常!!!");

与 std::promise 的对比

虽然手写版实现了链式调用，但标准库的 std::promise 在底层实现上更为稳健。以下是两者的详细对比。

基础功能对比

实现细节差异

1. 状态管理：CPromise 通过自定义枚举管理状态，灵活但需自行保证线程安全；std::promise 由标准库保障一致性。
2. 回调机制：CPromise 直接存储回调函数列表；std::promise 通常配合 std::future，通过 get 方法触发阻塞或通知。
3. 异步支持：CPromise 本身不包含异步调度，需结合 std::thread；std::promise 常与 std::async 或线程池配合使用。
4. 链式调用：这是手写版最大的优势，CPromise 支持链式调用，而 std::promise 原生不支持。

代码示例对比

CPromise 示例

CPromise<int>* promise = new CPromise<int>();
promise->then([](int ele) -> void {
    std::cout << "结果:" << ele << std::endl;
})->onCatch([](const std::string& reason) -> void {
    std::cout << "错误:" << reason << std::endl;
});
promise->reject("网络异常!!!");

std::promise 示例

#include <future>
#include <thread>
#include <iostream>

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();

    // 异步操作
    std::thread([&prom]() {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        prom.set_value(42);
    }).detach();

    // 注册回调
    fut.then([](std::future<int> fut) {
        try {
            int result = fut.get();
            std::cout << "结果:" << result << std::endl;
        } catch (const std::exception& e) {
            std::cout << "错误:" << e.what() << std::endl;
        }
    });

    // 主线程阻塞等待
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 0;
}

优缺点分析

• CPromise

  • 优点：代码简洁，易于理解；支持链式调用，使用方式类似前端 Promise；适合作为学习 Promise 实现原理的示例。
  • 缺点：不支持内置异步操作，需结合线程实现；功能较为基础，缺乏高级特性。

• std::promise

  • 优点：内置异步支持，与 std::future 配合使用，功能强大；标准库实现，性能优化和稳定性有保障；兼容性好。
  • 缺点：使用方式较为复杂，缺乏链式调用的支持；回调机制不够灵活，无法像前端 Promise 那样优雅地处理异步流程。

总结

通过手写 CPromise，我们可以深入理解 Promise 的实现原理，包括状态管理、回调注册与执行等核心机制。然而，在实际开发中，std::promise 仍然是更好的选择，因为它提供了更强大的功能和更好的性能保障。

对于开发者来说，理解 std::promise 的工作原理以及其与手写实现的异同点，有助于更好地选择合适的工具来处理异步操作。同时，手写实现虽然功能有限，但作为学习和探索的工具，仍然具有重要的价值。