C++11 手写 Promise：原理、实现与 std::promise 对比

核心解决的问题

1. 回调地狱：链式调用消除了深层嵌套，让代码结构扁平化。
2. 统一错误处理：通过 catch 方法集中捕获异步过程中的异常。
3. 可读性提升：异步逻辑的书写习惯更接近同步代码，易于理解。
4. 并发管理：借助 Promise.all 和 Promise.race，灵活控制执行顺序。

手写 C++ Promise 实现

类结构设计

为了实现类似前端的体验，我们需要定义状态枚举和回调类型。这里我们将类命名为 CPromise（修正了原文笔误），包含结果存储、拒绝原因、当前状态以及回调列表。

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;      // 当前状态 (PENDING, FULFILLED, REJECTED)
    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：分别用于存储最终结果或错误信息。
• m_state：管理 Promise 的生命周期状态。
• m_resolves / m_rejects：队列形式存储待执行的回调。

构造函数

初始化时，状态默认为 PENDING（等待中）。

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

resolve 方法

当异步操作成功完成时调用。如果状态仍是 PENDING，则更新为 FULFILLED 并立即执行所有已注册的回调。

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

reject 方法

处理异常情况。将状态置为 REJECTED 并触发失败回调。

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

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;
}

onCatch 方法

注册错误处理回调。逻辑与 then 类似，但针对 REJECTED 状态。

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);
    }
}

链式调用示例

通过组合 then 和 onCatch，我们可以写出非常清晰的异步流程。

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 与 CPromise 对比

基础功能对比

实现细节差异

1. 状态管理

手写版本通过自定义枚举 CPromiseState 显式控制状态流转，灵活性高但需自行保证线程安全。std::promise 的状态由标准库保障，用户无需关心底层锁机制。

2. 回调机制

手写版通过 then 直接注册回调函数，类似前端体验。std::promise 通常配合 std::future 使用，通过 get() 阻塞获取结果，或者在 C++20 之前缺乏原生的回调链式支持。

3. 异步模型

手写版需要开发者自己结合 std::thread 模拟异步。std::promise 设计初衷就是与 std::async 或线程配合，更适合系统级任务调度。

4. 链式调用

手写版通过返回 this 轻松实现链式调用。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->resolve(42);

标准库 std::promise 示例

注意：C++11 的 std::future 没有 then 方法，以下示例使用标准的 get() 方式获取结果。

#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();

    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

• 优点：语法简洁，支持链式调用，贴近前端思维，适合学习原理。
• 缺点：缺少线程安全保护，无高级特性，生产环境需谨慎使用。

std::promise

• 优点：标准库实现，性能稳定，线程安全有保障，适合系统编程。
• 缺点：API 相对繁琐，缺乏链式调用能力，异步流程表达不如 Promise 直观。

总结与展望

通过手写 CPromise，我们不仅复现了 Promise 的核心机制——状态机与回调队列，还深刻理解了其与 C++ 标准库 std::promise 在设计哲学上的差异。

在实际开发中，如果追求代码的简洁性和链式表达能力，手写的 Promise 模式（或第三方库如 Boost.Asio）可能更合适；若关注稳定性、线程安全和生态兼容性，std::promise 依然是首选。理解两者的权衡，能帮助我们在不同场景下选择最合适的异步解决方案。