基于C++20协程与腾讯云COS SDK的高性能异步文件上传系统设计与实践

#include <coroutine>
#include <qcloud_cos/CosAPI.h>
#include <memory>
#include <optional>

class CosAwaiter {
public:
    // 必须定义 promise_type 以支持 co_await
    struct promise_type {
        CosAwaiter get_return_object() {
            return CosAwaiter{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { exception_ = std::current_exception(); }

        std::exception_ptr exception_;
        std::optional<qcloud_cos::PutObjectResp> response_;
        std::optional<qcloud_cos::CosResult> result_;
    };

    CosAwaiter(std::coroutine_handle<promise_type> h) : handle_(h) {}
    ~CosAwaiter() { if (handle_) handle_.destroy(); }

    // 是否挂起：返回 true 表示挂起
    bool await_ready() noexcept { return false; }

    // 挂起时调用，保存当前协程句柄，并启动异步操作
    void await_suspend(std::coroutine_handle<> awaiting) {
        // 将当前协程句柄存入上下文，供回调使用
        this->awaiting_ = awaiting;
        // 假设外部持有 CosAPI 实例，调用异步 PutObject
        auto req = std::make_shared<qcloud_cos::PutObjectReq>();
        // ... 设置文件路径、bucket等（通过构造参数传入，此处简化）
        // 调用SDK异步接口，传入lambda捕获 this
        cos_api_->PutObjectAsync(req, [this](const qcloud_cos::CosResult& result, 
                                            const qcloud_cos::PutObjectResp& resp) {
            // 回调在线程池中执行，需将结果传递给协程
            promise_type& promise = handle_.promise();
            promise.result_ = result;
            promise.response_ = resp;
            // 恢复协程
            awaiting_.resume();
        });
    }

    // 协程恢复后，co_await 表达式的结果
    bool await_resume() {
        auto& promise = handle_.promise();
        if (promise.exception_) std::rethrow_exception(promise.exception_);
        // 检查 result 是否成功，否则抛出或返回 false
        return promise.result_.has_value() && promise.result_->IsSucc();
    }

private:
    std::coroutine_handle<promise_type> handle_;
    std::coroutine_handle<> awaiting_;
    qcloud_cos::CosAPI* cos_api_; // 外部注入
};

#include <semaphore>
class AsyncSemaphore {
    std::counting_semaphore<> sem_;
public:
    explicit AsyncSemaphore(size_t max) : sem_(max) {}
    auto acquire() {
        struct Awaiter {
            std::counting_semaphore<>* sem;
            bool await_ready() noexcept { return false; }
            void await_suspend(std::coroutine_handle<>) { sem->acquire(); }
            void await_resume() noexcept {}
        };
        return Awaiter{&sem_};
    }
    void release() { sem_.release(); }
};

AsyncSemaphore sem(10); // 最大10个并发上传
Task<bool> upload_with_limit(const std::string& path) {
    co_await sem.acquire();        // 获取许可，若满则挂起
    bool ok = co_await upload_file(path);
    sem.release();
    co_return ok;
}

template<typename T>
struct Task {
    struct promise_type {
        T result;
        std::exception_ptr exception;
        auto get_return_object() { 
            return Task{std::coroutine_handle<promise_type>::from_promise(*this)}; 
        }
        auto initial_suspend() { return std::suspend_always{}; } // 惰性启动
        auto final_suspend() noexcept { return std::suspend_always{}; }
        void unhandled_exception() { exception = std::current_exception(); }
        void return_value(T val) { result = std::move(val); }
    };
    std::coroutine_handle<promise_type> handle;
    T get() { 
        if (!handle.done()) handle.resume(); 
        if (handle.promise().exception) std::rethrow_exception(handle.promise().exception);
        return std::move(handle.promise().result);
    }
    // ... 析构等
};