C++11 手写 Promise：原理剖析与 std::promise 对比

核心优势

1. 解决回调嵌套：链式调用避免了深层嵌套，逻辑更清晰。
2. 统一错误处理：通过 catch 集中捕获异常，无需在每个回调中重复处理。
3. 并发管理：Promise.all 和 race 提供了灵活的并发控制策略。

手写 C++ Promise 实现

为了理解 Promise 的本质，我们尝试用 C++11 实现一个类似的结构。这里我们定义一个名为 CProimse 的模板类。

类结构设计

核心在于状态管理和回调队列。我们需要记录当前是等待中、成功还是失败，并存储待执行的回调函数。

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

    Element m_element;          // 成功结果
    std::string m_reason;       // 失败原因
    CProimseState m_state;      // 当前状态 (PENDING/FULFILLED/REJECTED)
    std::list<Resolve> m_resolves; // 成功回调列表
    std::list<Reject> m_rejects;   // 失败回调列表

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

状态流转与回调注册

构造函数初始化状态为 PENDING。关键在于 resolve 和 reject 方法，它们负责状态变更并触发已注册的回调。

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

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

链式调用支持

then 方法允许注册成功回调。如果状态已完成，立即执行；否则加入队列。返回 this 指针是实现链式调用的关键。

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

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

使用示例

通过链式调用，我们可以清晰地表达异步流程。

CProimse<int>* proimse = new CProimse<int>();
proimse->then([](int ele) -> void {
    std::cout << "结果：" << ele << std::endl;
})->onCatch([](const std::string& reason) -> void {
    std::cout << "错误：" << reason << std::endl;
});

proimse->reject("网络异常!!!");

std::promise 与 CProimse 对比

虽然两者都用于异步通信，但设计哲学和使用场景有所不同。

功能对比

实现细节差异

• 状态管理：自定义实现完全掌控状态机，适合学习原理；std::promise 则隐藏了底层细节，更安全。
• 回调执行：自定义版本直接调用函数对象；std::promise 通常通过 future.get() 阻塞获取结果，或者结合 std::async 使用。
• 链式调用：这是最大的区别。自定义实现模仿了 JS Promise 的链式体验，而 std::promise 更偏向于传统的 Future-Promise 模式。

代码示例对比

自定义 CProimse

CProimse<int>* p = new CProimse<int>();
p->then([](int v){ std::cout << v; });
p->resolve(42);

标准库 std::promise

C++11 标准库的 std::future 并不直接支持 .then() 回调（这通常是 JS 概念或第三方库特性）。标准做法是使用 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();

    // 主线程等待结果
    int result = fut.get();
    std::cout << "结果：" << result << std::endl;

    return 0;
}

优缺点分析

• 自定义 CProimse：优点是语法灵活，支持链式调用，接近前端思维；缺点是缺乏内存安全保证，需自行管理生命周期，且无内置异步调度。
• std::promise：优点是类型安全，与标准库生态兼容性好，性能稳定；缺点是无法直接链式处理结果，交互略显繁琐。

总结

通过手写 CProimse，我们能更直观地理解 Promise 的状态机模型和回调分发机制。在实际 C++ 开发中，std::promise 依然是处理跨线程通信的首选，因为它经过了充分测试和优化。然而，理解手写实现的原理，有助于我们在面对复杂异步需求时，做出更合适的技术选型。