C++11 手写 Promise 实现与 std::promise 对比

C++11 手写 Promise 实现与 std::promise 对比

在前端开发中，Promise 是处理异步操作的重要工具。它通过将异步操作封装在 Promise 实例中，解决了传统回调地狱的问题，提高了代码的可读性和可维护性。虽然 Promise 的概念常被视为前端专属，但在 C++11 标准中也引入了 std::promise，用于实现类似的功能。

本文将从一个手写的 C++ Promise 实现（基于 C++11）出发，分析其工作原理，并与 std::promise 进行对比，探讨两者的异同点以及适用场景。

前端 Promise 的应用与优势

常见应用场景

定时器 Promise 还可以用于处理定时器，使代码更加直观。

function timeout(ms) {
    return new Promise((resolve) => {
        setTimeout(resolve, ms);
    });
}
timeout(1000).then(() => {
    console.log('1 秒后执行');
});

网络请求 Promise 可以用于处理 AJAX 请求，简化异步数据获取的逻辑。

fetch('https://api.example.com/data')
    .then(response => response.json())
    .then(data => {
        console.log('获取到数据:', data);
    })
    .catch(error => {
        console.error('请求失败:', error);
    });

并发请求

使用 Promise.all 可以同时处理多个异步请求。

const promise1 = fetch('https://api.example.com/data1');
const promise2 = fetch('https://api.example.com/data2');

Promise.all([promise1, promise2])
    .then(responses => {
        const [data1, data2] = responses.map(response => response.json());
        return Promise.all([data1, data2]);
    })
    .then(([data1, data2]) => {
        console.log('两个数据都获取成功:', data1, data2);
    })
    .catch(error => {
        console.error('至少一个请求失败:', error);
    });

Promise 解决的问题

1. 回调地狱：通过链式调用，Promise 解决了传统回调嵌套导致的代码难以阅读和维护的问题。
2. 错误处理：Promise 提供了统一的错误处理机制，通过 catch 方法可以集中处理所有异步操作中的错误。
3. 代码可读性：Promise 使得异步代码的逻辑更加清晰，符合同步代码的书写习惯。
4. 并发控制：通过 Promise.all 和 Promise.race，可以方便地控制多个异步操作的执行顺序和结果。

手写 C++ Promise 实现

类结构与成员变量

我们定义一个模板类来模拟 Promise 的行为，核心在于状态管理和回调队列。

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 存储最终结果或错误信息，而 m_state 跟踪 Promise 的生命周期，初始为 PENDING。

构造函数

初始化时，Promise 处于等待状态。

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

resolve 方法

当异步操作成功完成时，调用此方法。它会更新状态并立即触发所有已注册的回调。

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

注意这里有一个细节：只有当状态为 PENDING 时才允许变更，防止重复设置状态。

reject 方法

如果操作失败，则进入拒绝状态并通知所有监听者。

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

then 方法

这是链式调用的关键。如果 Promise 已经完成，直接执行回调；否则将回调加入队列等待。

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

返回 this 是为了支持链式调用，让代码更流畅。

onCatch 方法

类似于 then，但专门处理错误情况。

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，我们可以写出非常清晰的异步流程。

proimse->then([](int ele) -> void {
    std::cout << ele << std::endl;
})->onCatch([](const std::string& reason) -> void {
    std::cout << reason << std::endl;
});

完整使用示例

CPromise<int>* proimse = new CPromise<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 与 CPromise 对比

1. 基础功能对比

功能	CPromise 实现	std::promise
状态管理	手动实现	标准库实现
回调注册与执行	手动实现	标准库实现
异步支持	需结合线程	内置支持
链式调用	支持	不支持

2. 实现细节对比

(1) 状态管理

• CPromise：通过自定义枚举 CPromiseState 管理状态，灵活性高但需要自行维护。
• std::promise：状态管理由标准库封装，用户无需关注底层细节，更安全。

(2) 回调注册与执行

• CPromise：手动维护回调队列，通过 then 和 onCatch 方法注册回调，类似前端体验。
• std::promise：通过 std::future 与 std::promise 配合，通常通过 get 阻塞获取结果，或通过 future.then 注册回调。

(3) 异步支持

• CPromise：本身不包含异步调度，需要结合 std::thread 或其他框架实现。
• std::promise：内置支持异步操作，通常与 std::async 或 std::thread 配合使用。

(4) 链式调用

• CPromise：支持链式调用，通过返回 this 实现，代码更简洁。
• std::promise：原生不支持链式调用，无法直接链式注册回调。

3. 代码示例对比

(1) CPromise 示例

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

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

4. 优缺点分析

(1) CPromise

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

(2) std::promise

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

总结与展望

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

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